.VB File Format – Operators and expressions

Precedence

From the highest to the lowest (the specification’s table; every binary operator is left-associative):

The operators

Dim a = 7 \ 2          ' integer division: 3
Dim b = 7 / 2          ' floating division: 3.5
Dim c = 7 Mod 3        ' 1
Dim d = 2 ^ 10         ' 1024.0 (Double)
Dim e = "a" & "b" & 1  ' concatenation
Dim f = 1 << 3         ' shift: 8
Dim g = 256 >> 2       ' 64
Dim h = Not True
Dim i = True And False
Dim j = True AndAlso False
Dim k = True Or False
Dim l = True OrElse False
Dim m = True Xor True
Dim n = "apple" Like "a*"
Dim o = "x" <> "y"
Dim x As Object = "s"
Dim p = x Is Nothing
Dim q = x IsNot Nothing
Dim r = TypeOf x Is String
Dim s = TypeOf x IsNot Integer

Assignment

x = expression assigns; there is no assignment expression (an = inside an expression is a comparison). Compound forms apply an operator and assign: += -= *= /= \= ^= &= <<= >>=. Mid(text, start, length) = "xy" overwrites part of a string. Arguments can be named with := (Foo(count:=3)).

Dim total As Integer = 0
total += 5 : total -= 1 : total *= 3 : total \= 2
Dim txt = "x"
txt &= "y"
total <<= 1
total >>= 1

Other expression forms

Dim t = If(a > 1, "big", "small")                 ' conditional: only one branch is evaluated
Dim u = If(name, "default")                       ' coalescing: name if not Nothing
Dim v = node?.Name                                ' null-conditional (version 14)
Dim w = node?.Next1?.Name
Dim lookup = dict!one                             ' dictionary access: dict("one")
Dim size = GetType(Integer).Name
Dim nm = NameOf(total)                            ' "total"
Dim list = New List(Of Integer)() From {1, 2, 3}  ' collection initialiser
Dim p = New With {.Id = 1, .Name = "x"}           ' anonymous type
Dim k = New With {Key .Id = 1}                    ' Key properties form equality
Dim n = New Node With {.Name = "n"}               ' object initialiser
Dim f As Func(Of Integer, Integer) = AddressOf Twice  ' delegate to a method

• If(a, b, c) and If(a, b) evaluate lazily; the older function IIf evaluates both. A nullable If(x, 0) unwraps.
• ?. and ?( stop at Nothing and give Nothing (a nullable for a value type); they also work for indexing, a?(0).
• Member access: x.Member; inside With x … End With a leading .Member means x.Member; Me is the current object, MyBase the base class, MyClass the current class bypassing overrides; x!Name is x.Item("Name"); x.<a>, x.@a and x...<a> are XML member access.
• Calls: Foo(1, 2); a method with no parameters may be called without brackets as a statement, and a call may use named arguments (Foo(b:=2, a:=1)); a bracket after an expression selects an index of an array or a default property. Call Foo(1) is the old statement form.
• Creation: New T(args) with an optional With {…} (object initialiser) or From {…} (collection initialiser), arrays New Integer() {1, 2} and New T(2) {…}, anonymous types New With {…} and delegate creation New Func(Of Integer)(AddressOf M).
• Type expressions: GetType(T) gives a System.Type, NameOf(x) the name as a string, GetXmlNamespace(p) an XML namespace, and AddressOf M a delegate to a method. Await waits for a task (see procedures).
• Lambdas and queries have their own pages: lambdas and LINQ.

A constant expression (a literal, a Const, or operators on them) is evaluated by the compiler. On Object, with Option Strict Off, member access and operators are late bound: the operation is resolved at run time (this is also how COM objects are used).

Not described

Known, not yet covered

• Reference: the result type of each arithmetic and comparison operator for each pair of primitive types, overflow behaviour, operator resolution and the rules for user-defined operators are in the operator chapters of the specification and are not tabulated here.
• Reference: overload resolution, extension method lookup, default instances of forms and the rules for late binding are only mentioned.

See also

• Statements and control flow – how expressions are used
• Lexical structure – the operator tokens