Local Type Inference (Visual Basic)
The Visual Basic compiler uses type inference to determine the data types of local variables declared without an As clause. The compiler infers the type of the variable from the type of the initialization expression. This enables you to declare variables without explicitly stating a type, as shown in the following example. As a result of the declarations, both num1 and num2 are strongly typed as integers.
If you do not want num2 in the previous example to be typed as an Integer, you can specify another type by using a declaration like Dim num3 As Object = 3 or Dim num4 As Double = 3.
Local type inference applies at procedure level. It cannot be used to declare variables at module level (within a class, structure, module, or interface but not within a procedure or block). If num2 in the previous example were a field of a class instead of a local variable in a procedure, the declaration would cause an error with Option Strict on, and would classify num2 as an Object with Option Strict off. Similarly, local type inference does not apply to procedure level variables declared as Static.
Code that uses type inference resembles code that relies on late binding. However, type inference strongly types the variable instead of leaving it as Object. The compiler uses a variable's initializer to determine the variable's type at compile time to produce early-bound code. In the previous example, num2, like num1, is typed as an Integer.
The behavior of early-bound variables differs from that of late-bound variables, for which the type is known only at run time. Knowing the type early enables the compiler to identify problems before execution, allocate memory precisely, and perform other optimizations. Early binding also enables the Visual Basic integrated development environment (IDE) to provide IntelliSense Help about the members of an object. Early binding is also preferred for performance. This is because all data stored in a late-bound variable must be wrapped as type Object, and accessing members of the type at run time makes the program slower.
Type inference occurs when a local variable is declared without an As clause and initialized. The compiler uses the type of the assigned initial value as the type of the variable. For example, each of the following lines of code declares a variable of type String.
The following code demonstrates two equivalent ways to create an array of integers.
It is convenient to use type inference to determine the type of a loop control variable. In the following code, the compiler infers that number is an Integer because someNumbers2 from the previous example is an array of integers.
Local type inference can be used in Using statements to establish the type of the resource name, as the following example demonstrates.
The type of a variable can also be inferred from the return values of functions, as the following example demonstrates. Both pList1 and pList2 are arrays of processes because Process.GetProcesses returns an array of processes.
Option Infer enables you to specify whether local type inference is allowed in a particular file. To enable or to block the option, type one of the following statements at the start of the file.
Option Infer On
Option Infer Off
If you do not specify a value for Option Infer in your code, the compiler default is Option Infer On. For projects upgraded from Visual Basic 2008 or earlier, the compiler default is Option Infer Off.
If the value set for Option Infer in a file conflicts with the value set in the IDE or on the command line, the value in the file has precedence.