|
Code |
Description |
| AddHandler |
Associates an event with an event handler at run time. |
| AddressOf |
Creates a procedure delegate instance that references the
specific procedure. |
| Alias |
Indicates that an external procedure has another name in its
DLL. |
| And |
Performs a logical conjunction on two Boolean expressions,
or a bitwise conjunction on two numeric expressions. |
| AndAlso |
Performs short-circuiting logical conjunction on two expressions.
|
| As |
Introduces an As clause, which identifies a data type
in a declaration statement or a constraint list on a generic type parameter. |
| Boolean |
Holds values that can be only True or False.
The keywords True and False correspond to the two states of Boolean
variables. |
| ByRef |
Specifies that an argument is passed in such a way that the
called procedure can change the value of a variable underlying the argument in
the calling code. |
| Byte |
Holds unsigned 8-bit (1-byte) integers ranging in value from
0 through 255. |
| ByVal |
Specifies that an argument is passed in
such a way that the called procedure or property cannot change the value of a
variable underlying the argument in the calling code. |
| Call |
Transfers control to a Function, Sub, or
dynamic-link library (DLL) procedure. |
| Case |
Introduces a value or set of values against which the value
of an expression is to be tested. |
| Catch |
Provides a way to handle some or all possible errors that may
occur in a given block of code, while still running code. |
| CBool |
Any valid Char or String or numeric expression |
| CByte |
0 through 255 (unsigned); fractional parts are rounded.1 |
| CChar |
Any valid Char or String expression; only first
character of a String is converted; value can be 0 through 65535
(unsigned). |
| CDate |
Any valid representation of a date and time. |
| CDec |
+/-79,228,162,514,264,337,593,543,950,335 for zero-scaled
numbers, that is, numbers with no decimal places. For numbers with 28 decimal
places, the range is +/-7.9228162514264337593543950335. The smallest possible
non-zero number is 0.0000000000000000000000000001 (+/-1E-28). |
| CDbl |
-1.79769313486231570E+308 through -4.94065645841246544E-324
for negative values; 4.94065645841246544E-324 through 1.79769313486231570E+308
for positive values. |
| Char |
Holds unsigned 16-bit (2-byte) code points ranging in value
from 0 through 65535. Each code point, or character code, represents a
single Unicode character. |
| CInt |
-2,147,483,648 through 2,147,483,647; fractional parts are
rounded.1 |
| Class |
Constrains a generic type parameter to require that any type argument passed to
it be a reference type, or introduces a Class
Statement (Visual Basic).
|
| CLng |
-9,223,372,036,854,775,808 through
9,223,372,036,854,775,807; fractional parts are rounded.1 |
| CObj |
Any valid expression. |
| Const |
Declares and defines one or more constants. |
| Continue |
Transfers control immediately to the next iteration of a
loop. |
| CSByte |
-128 through 127; fractional parts are rounded.1 |
| CShort |
-32,768 through 32,767; fractional parts are rounded.1 |
| CSng |
-3.402823E+38 through -1.401298E-45 for negative values;
1.401298E-45 through 3.402823E+38 for positive values. |
| CStr |
Returns for CStr depend on the expression
argument. See Return
Values for the CStr Function. |
| CType |
The CType
Function takes a second argument, typename,
and coerces expression to typename,
where typename can be any data type, structure,
class, or interface to which there exists a valid conversion. |
| CUInt |
0 through 4,294,967,295 (unsigned); fractional parts are
rounded.1 |
| CULng |
0 through 18,446,744,073,709,551,615 (unsigned); fractional
parts are rounded.1 |
| CUShort |
0 through 65,535 (unsigned); fractional parts are rounded.1 |
| Date |
Holds IEEE 64-bit (8-byte) values that represent dates
ranging from January 1 of the year 0001 through December 31 of the year 9999,
and times from 12:00:00 AM (midnight) through 11:59:59.9999999 PM. Each
increment represents 100 nanoseconds of elapsed time since the beginning of
January 1 of the year 1 in the Gregorian calendar. The maximum value represents
100 nanoseconds before the beginning of January 1 of the year 10000. |
| Decimal |
Holds signed 128-bit (16-byte) values representing 96-bit
(12-byte) integer numbers scaled by a variable power of 10. The scaling factor
specifies the number of digits to the right of the decimal point; it ranges
from 0 through 28. With a scale of 0 (no decimal places), the largest possible
value is +/-79,228,162,514,264,337,593,543,950,335
(+/-7.9228162514264337593543950335E+28). With 28 decimal places, the largest
value is +/-7.9228162514264337593543950335, and the smallest nonzero value is
+/-0.0000000000000000000000000001 (+/-1E-28). |
| Declare |
Declares a reference to a procedure implemented in an
external file. |
| Default |
Identifies a property as the default property of its class,
structure, or interface. |
| Delegate |
Used to declare a delegate. A delegate is a reference type
that refers to a Shared method of a type or to an instance method of an
object. Any procedure with matching parameter types and return type may be used
to create an instance of this delegate class. The procedure can then later be
invoked by means of the delegate instance. |
| Dim |
Declares and allocates storage space for one or more
variables. |
| DirectCast |
Introduces a type conversion operation based on inheritance
or implementation. |
| Do |
Repeats a block of statements while a Boolean condition is True or
until the condition becomes True.
|
| Double |
Holds signed IEEE 64-bit (8-byte) double-precision
floating-point numbers ranging in value from -1.79769313486231570E+308 through
-4.94065645841246544E-324 for negative values and from 4.94065645841246544E-324
through 1.79769313486231570E+308 for positive values. Double-precision numbers
store an approximation of a real number. |
| Each |
Specifies the loop variable to be used in a For Each loop. |
| Else |
Introduces a group of statements to be run or compiled if no
other conditional group of statements has been run or compiled. |
| ElseIF |
Introduces a condition to be tested if the previous
conditional test has failed. |
| End |
Terminates execution immediately. |
| EndIF |
|
| Enum |
Declares an enumeration and defines the values of its
members. |
| Erase |
Used to release array variables and deallocate the memory
used for their elements. |
| Error |
Simulates the occurrence of an error. |
| Event |
Declares a user-defined event. |
| Exit |
Exits a procedure or block and transfers control immediately
to the statement following the procedure call or the block definition. |
| False |
Represents a Boolean value that fails a conditional
test. |
| Finally |
Provides a way to handle some or all possible errors that may occur in a given
block of code, while still running code.
|
| For |
Introduces a loop that is iterated with different values of a
loop variable. |
| Friend |
Specifies that one or more declared programming elements are accessible only
from within the assembly that contains their declaration.
|
| Function |
Declares the name, parameters, and code that define a Function
procedure. |
| Get |
Declares a Get property procedure used to retrieve the value of a
property.
|
| GetType |
Returns a Type
object for the specified type. The Type object provides information
about the type such as its properties, methods, and events. |
| Global |
Allows you to access a .NET Framework programming element
when you have blocked it with your namespace structure. |
| GoSub |
|
| GoTo |
Branches unconditionally to a specified line within a
procedure. |
| Handles |
Declares that a procedure handles a specified event. |
| If |
Conditionally executes a group of statements, depending on
the value of an expression. |
| Implements |
Specifies one or more interfaces, or interface members, that must be
implemented in the class or structure definition in which it appears.
|
| Imports |
Imports namespaces or programming elements defined in
referenced projects and assemblies. Also imports namespaces or elements defined
within the same project. |
| In |
Specifies the group that the loop variable is to traverse in
a For Each loop. |
| Inherits |
Causes the current class or interface to inherit the attributes, variables,
properties, procedures, and events from another class or set of interfaces.
|
| Integer |
Holds signed 32-bit (4-byte) integers ranging in value from -2,147,483,648
through 2,147,483,647.
|
| Interface |
Declares the name of an interface and introduces the
definitions of the members that the interface comprises. |
| Is |
Introduces an Is clause that makes a comparison.
|
| IsNot |
Compares two object reference variables.
|
| Let |
|
| Lib |
Introduces a Lib clause, which identifies the external
file (DLL or code resource) containing an external procedure. |
| Like |
Compares a string against a pattern.
|
| Long |
Holds signed 64-bit (8-byte) integers ranging in value from
-9,223,372,036,854,775,808 through 9,223,372,036,854,775,807 (9.2...E+18).
|
| Loop |
Terminates a loop introduced with a Do statement. |
| Me |
Provides a way to refer to the specific instance of a class
or structure in which the code is currently executing. |
| Mod |
Divides two numbers and returns only the remainder. |
| Module |
Declares the name of a module and introduces the definition
of the variables, properties, events, and procedures that the module comprises. |
| MustInherit |
Specifies that a class can be used only as a base class and
that you cannot create an object directly from it. |
| MustOverride |
Specifies that a property or procedure is not implemented in
this class and must be overridden in a derived class before it can be used. |
| MyBase |
Provides a way to refer to the base class of the current
class instance. |
| MyClass |
Provides a way to refer to the current class instance members
without them being replaced by any derived class overrides. |
| Namespace |
Declares the name of a namespace and causes the source code
following the declaration to be compiled within that namespace. |
| Narrowing |
Indicates that a conversion operator (CType) converts
a class or structure to a type that might not be able to hold some of the
possible values of the original class or structure. |
| New |
Introduces a New clause to create a new object
instance, or specifies a constructor constraint on a type parameter. |
| Next |
Terminates a loop that is iterated with different values of a
loop variable, or specifies that execution should continue with the statement
following the statement that generated an error. |
| Not |
Performs logical negation on a Boolean expression, or
bitwise negation on a numeric expression. |
| Nothing |
Represents the default value of any data type. |
| NotInheritable |
Specifies that a class cannot be used as a base class. |
| NotOverridable |
Specifies that a property or procedure cannot be overridden
in a derived class. |
| Object |
Holds 32-bit (4-byte) addresses that refer to objects. You
can assign any reference type (string, array, class, or interface) to an Object
variable. An Object variable can also refer to data of any value type
(numeric, Boolean, Char, Date, structure, or enumeration). |
| Of |
Introduces an Of clause, which identifies a type
parameter on a generic class, structure, interface, delegate, or
procedure. For information on generic types, see Generic
Types in Visual Basic. |
| On |
Introduces a response to a run-time error or turns a compiler
option on. |
| Operator |
Declares the operator symbol, operands, and code that define
an operator procedure on a class or structure. |
| Option |
Introduces a statement that specifies a compiler option that
applies to the entire source file. |
| Optional |
Specifies that a procedure argument can be omitted when the
procedure is called. |
| Or |
Performs a logical disjunction on two Boolean expressions,
or a bitwise disjunction on two numeric expressions. |
| OrElse |
Performs short-circuiting inclusive logical disjunction on
two expressions. |
| Overloads |
Specifies that a property or procedure redeclares one or more
existing properties or procedures with the same name. |
| Overridable |
Specifies that a property or procedure can be overridden by
an identically named property or procedure in a derived class. |
| Overrides |
Specifies that a property or procedure overrides an
identically named property or procedure inherited from a base class. |
| ParamArray |
Specifies that a procedure parameter takes an optional array
of elements of the specified type. ParamArray can be used only on the
last parameter of a parameter list. |
| Partial |
Indicates that a class or structure declaration is a partial
definition of the class or structure. |
| Private |
Specifies that one or more declared programming elements are
accessible only from within their declaration context, including from within
any contained types. |
| Property |
Declares the name of a property, and the property procedures
used to store and retrieve the value of the property. |
| Protected |
Specifies that one or more declared programming elements are
accessible only from within their own class or from a derived class. |
| Public |
Specifies that one or more declared programming elements have
no access restrictions. |
| RaiseEvent |
Triggers an event declared at module level within a class,
form, or document. |
| ReadOnly |
Specifies that a variable or property can be read but not
written. |
| ReDim |
Reallocates storage space for an array variable. |
| REM |
Used to include explanatory remarks in the source code of a
program. |
| RemoveHandler |
Removes the association between an event and an event
handler. |
| Resume |
Specifies where execution should continue after an error has
been handled. |
| Return |
Returns control to the code that called a Function, Sub,
Get, Set, or Operator procedure. |
| SByte |
Holds signed 8-bit (1-byte) integers ranging in value from
-128 through 127. |
| Select |
Runs one of several groups of statements, depending on the
value of an expression. |
| Set |
Declares a Set property procedure used to assign a
value to a property. |
| Shadows |
Specifies that a declared programming element redeclares and
hides an identically named element, or set of overloaded elements, in a base
class. |
| Shared |
Specifies that one or more declared programming elements are
associated with a class or structure at large, and not with a specific instance
of the class or structure. |
| Short |
Holds signed 16-bit (2-byte) integers ranging in value from
-32,768 through 32,767. |
| Single |
Holds signed IEEE 32-bit (4-byte) single-precision
floating-point numbers ranging in value from -3.4028235E+38 through
-1.401298E-45 for negative values and from 1.401298E-45 through 3.4028235E+38
for positive values. Single-precision numbers store an approximation of a real
number. |
| Static |
Specifies that one or more declared local variables are to
remain in existence and retain their latest values after termination of the
procedure in which they are declared. |
| Step |
Specifies an increment value for a loop counter. |
| Stop |
Suspends execution |
| String |
Holds sequences of unsigned 16-bit (2-byte) code points
ranging in value from 0 through 65535. Each code point, or character
code, represents a single Unicode character. A string can contain from 0 to
approximately 2 billion (2 ^ 31) Unicode characters |
| Structure |
Constrains a generic type parameter to require that any type
argument passed to it be a value type, or introduces a Structure |
| Sub |
Declares the name, parameters, and code that define a Sub
procedure. |
| SyncLock |
Acquires an exclusive lock for a statement block before
executing the block |
| Then |
Introduces a statement block to be compiled or executed if a
tested condition is true. |
| Throw |
Throws an exception within a procedure. |
| To |
Separates the beginning and ending values of a loop counter
or of a value match range. |
| True |
Represents a Boolean value that passes a conditional
test. |
| Try |
Introduces a type conversion operation that does not throw an
exception. |
| TypeOf |
Compares an object reference variable to a data type. |
| Varient |
|
| Wend |
|
| UInteger |
Holds unsigned 32-bit (4-byte) integers ranging in value from
0 through 4,294,967,295. |
| ULong |
Holds unsigned 64-bit (8-byte) integers ranging in value from
0 through 18,446,744,073,709,551,615 (more than 1.84 times 10 ^ 18). |
| UShort |
Holds unsigned 16-bit (2-byte) integers ranging in value from
0 through 65,535. |
| Using |
Declares the beginning of a Using block and optionally
acquires the system resources that the block controls. |
| When |
Adds a conditional test to a Catch statement. |
| While |
Specifies a condition that allows the execution of a Do
loop to continue. |
| Widening |
Indicates that a conversion operator (CType) converts
a class or structure to a type that can hold all possible values of the
original class or structure. |
| With |
Executes a series of statements making repeated reference to
a single object or structure. |
| WithEvents |
Specifies that one or more declared member variables refer to
an instance of a class that can raise events. |
| WriteOnly |
Specifies that a property can be written but not read. |
| Xor |
Performs a logical exclusion on two Boolean expressions,
or a bitwise exclusion on two numeric expressions |
| #Const |
Defines conditional compiler constants for Visual Basic. |
| #Else |
Conditionally compiles selected blocks of Visual Basic code. |
| #ElseIf |
Conditionally compiles selected blocks of Visual Basic code. |
| #End |
Conditionally compiles selected blocks of Visual Basic code. |
| #If |
Conditionally compiles selected blocks of Visual Basic code. |