Implicitly Typed Local Variable In .NET

Implicitly Typed Local Variable

 

Implicitly typed local variable is a variable that can be declared without specifying the .NET type explicitly. In an implicitly typed local variable declaration, the type of the local variable is obtained from the expression used to initialize the variable. The type of the variable is inferred at compile time from the expression on the right side of the initialization statement.

 

Let us take some example of implicitly typed local variable.

var Int_ = 123;
var String_ = "Hello World";
var Array_ = newint[]
{
    10,
    11,
    12
};
var Stack_ = newStack();

Above implicit typed variables are similar to the following explicit typed variables;

int Int_ = 123;
string String_ = "Hello World";
Array Array_ = newint[]
{
    10,
    11,
    12
};
Stack Stack_ = newStack();

The “Implicitly Typed Local Variable” is a combined form of two terms, “Implicitly Typed” and “Local Variable”.

 

Implicit typed

 

The .NET Framework 2.0 or earlier describe that all variable must be declared explicitly. With each new variable name, the data type must be used as a prefix.

 

Example:

int Int_ = 123;
string String_ = "Hello World";

The .NET framework 3.0 introduced the “Implicitly Typed Local Variable” that instruct the compiler to identify the data type of variable according to its initial declaration.

var Int_ = 123; //Integer Type
var String_ = "Hello World"; // String Type

Local Variable:

 

The “Implicitly Typed Local Variable” may only be used within class members such as methods and property. It may not be used in any element of a class where the variable could be a part of the public interface. If we use “Implicitly Typed Local Variable” for global scope then the compiler will throw an error.

 

Example:

 

 

In the above image, we tried to declare a var variable as a global variable, but the compiler throws an error that var may only appear in the local scope.

 

Restrictions for “Implicitly Typed Local Variable”

 

Now we consider some restrictions for “Implicitly Typed Local Variable” that make it an unreliable variable for general purpose use.

 

Declaration must include an initializer:

 

We can’t declare an Implicitly typed Local Variable without any initialization. The declaration must include the initializing.

 

Example:

 

 

Initializer must be an expression

 

The initializer can’t be a collection or an object, but it can be a new expression that includes an object or collection initializer.

 

Example:

var Array_ =
{
    10,
    11,
    12
}; //Error Cannot initialize an implicitly-typed local variable with an array initializer

var Array_ = newint[]
{
    10,
    11,
    12
}; // No Error

Implicitly typed Local Variable can’t be null

 

We can’t use a null type for implicitly typed local variables.

 

 

Initializer must have the same data type

 

If we declare the implicitly typed local variable multiple types then each time initializers must have the same compile-time type. The implicitly-type local variable can’t be initialized with different types more than one time.

 

Example:

 

 

Can’t use as a parameter or return type in the method

 

Due to the local scope, we can’t use var as a parameter or as a return type for any method.

 

 

Uses of Implicitly Typed Local Variable

1. If we know the type that we want to use then we don’t have any need for var but if we don't have any idea about type then we can use var variable. So use var for anonymous types.
    
2. Var is also useful for LINQ (Language Integrated Query) queries.

Where to use

 

Only local-variable-declaration, for-initializer, resource-acquisition, and foreach-statement can contain implicitly typed local variable declarations.

 

Thanks for reading the article.