Windows apps
Collapse the table of content
Expand the table of content
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

Expressions in Visual Basic


The managed expression evaluator accepts most expressions written in Visual Basic. In the Immediate window, the expression evaluator only supports single-line statements.

The following sections offer specific information and discuss some of the expression types that are not supported or partially supported:

 Visual Basic does not support autoexpand rules for displaying the contents of a data type in meaningful form. For more information, see Displaying Elements of a Custom Data Type.

Simple casts work in the debugger:

 A = CStr(B)

The expression evaluator can evaluate variables that are statically typed as dynamic. It can also evaluate objects that implement the IDynamicObject interface. When objects that that implement the IDynamicObject interface are evaluated in the Watch window, a Dynamic View node is added. The Dynamic View node shows object members but does not allow editing the values of the members.

The following features of dynamic objects are not supported:

  • The compound operators +=, -=, %=, /=, and *=

  • Many casts, including numeric casts and type-argument casts

  • Method calls with more than two arguments

  • Property getters with more than two arguments

  • Property setters with arguments

  • Assigning to an indexer

  • The Boolean operators && and ||

The debugger supports the evaluation of functions, including overloaded functions. Therefore, you can enter either of the following expressions, and the debugger will call the correct version of the overloaded function:

 myFunction (param1)

 myFunction (param1, param2)

Evaluating a function in the debugger calls and executes the code for that function. If the function has side effects, such as allocating memory or changing the value of a global variable, evaluating the function in a debugger window will change the state of your program, which can produce unexpected results.

When you set a breakpoint on an overloaded function, the location of the breakpoint depends on how you specify the function. If you specify only the function name, the debugger will set one breakpoint on each overload of that function name. If you specify the complete signature, function name, and full argument list, the debugger sets one breakpoint on the specified overload.

Debugger expressions can use any identifier visible within the current scope. If the debugger is halted in function Magh, for example, you can use most identifiers visible within Magh, including variable names and function names. Local constants are not supported. You can set the value of any variable visible within the current scope.

The debugger can correctly display any variable of a primitive or intrinsic type. For variables of class type, the debugger correctly displays the value based on the derived-most type. If you have an object leo of type Lion, derived from type Cat, you can evaluate leo.Clawlength and get the correct value for an object of type Lion.

You cannot use import aliases in the debugger windows.

Object variables that contain intrinsic variable types, such as integer, are displayed and edited in a manner that may appear counterintuitive. For example, suppose your source code contains object variable like this:

 Dim obj As Object = 5

The Watch window shows the value of variable obj as:

 5 {Integer}

To change the value of this variable to 6, you would enter:


You would not enter:

 6 {Integer}

After you edit the value, you will notice that the debugger adds the {Integer} for you.

The debugger correctly evaluates most operators, including:

  • Arithmetical operators: ( expr1+ expr2, expr1- expr2, expr1* expr2, expr1/ expr2, expr1\expr2, expr1^expr2 , expr1Modexpr2 ).

  • Assignment operators: ( var1= expr2, var1^= expr2, var1*= expr2, var1/= expr2, var1\= expr2, var1+= expr2, var1-= expr2, var1&= expr2).

  • Comparison operators: (expr2< expr2, expr2<= expr2, expr1> expr2, expr1>= expr2, expr1= expr2, expr1<> expr2).

  • Concatenation operators: (expr1& expr2, expr1+ expr2).

  • Logical operators: (expr1And expr2, expr1Or expr2, expr1XOr expr2, expr1AndAlso expr2, expr1OrElse expr2, Notexpr1).

  • Unary operators: ( - expr1, Not expr1, GetType (type) ).

The debugger can evaluate properties in any variable window. However, evaluating a property in the debugger can have side effects, such as changing variable values, that affect program results. To protect against side effects caused by accidental evaluation, you can turn property evaluation off in the General, Debugging, Options dialog box.

In Visual Basic, you can use the Length operator on a string:



 "hello world".Length

In Visual Basic, you can use the TypeOf operator in the debugger windows:

 TypeOf expressionIs type

For example,

 TypeOf Me Is Integer

displays the value false.

If you use TypeOf, it must part of an expression that uses Is. If you use TypeOf without Is, you will get the following error message:

 Is required

The following Visual Basic keywords are not supported in debugger window expressions:

  •  AddressOf

  •  End

  •  Error

  •  Exit

  •  Goto

  •  On Error

  •  Return

  •  Resume

  •  Select/Case

  •  Stop

  •  SyncLock

  •  Throw

  •  Try/Catch/Finally

  •  With

In addition, no namespace or module level keywords, such as End Sub or Module, are supported.

You cannot declare explicit new variables in debugger windows.

However, you can assign to an implicit variable in the Immediate window. These implicit variables are scoped to the debugger and not accessible outside the debugger. For example, the statement o = 5 will implicitly create a new variable o and assign the value 5 to it. Such implicit variables are of type Object unless the type can be inferred by the debugger.

You cannot call WebMethods from debugger windows.

© 2018 Microsoft