C# | Implicitly Typed Local Variables – var

Implicitly typed variables are those variables that are declared without specifying the .NET type explicitly. In an implicitly typed variable, the type of the variable is automatically deduced at compile time by the compiler from the value used to initialize the variable.

The implicitly typed variable concept is introduced in C# 3.0. The implicitly typed variable is not designed to replace the normal variable declaration, it is designed to handle some special-case situations like LINQ(Language-Integrated Query).

Question: Why it is termed Local?

Answer: It is not allowed to use var as a parameter value or return type in the method or define it at the class level etc. because the scope of the implicitly typed variable is local.

Example of Implicitly Typed Local Variables

// C# program to illustrate
// implicitly typed local variable
using System;

public class GFG {
    
    // declaring and initializing implicitly
    // typed local variable at class level. 
    // It will give compile time error
    var imp = 15;

    // Main method
    static public void Main()
    {

        // trying to print the value of 'imp'
        Console.WriteLine(GFG.imp);
    }
}

Compile-Time Error:

prog.cs(10,2): error CS0825: The contextual keyword `var' may only appear within a local variable declaration

Important Points of Implicitly Typed Local Variables

Implicitly typed variables are generally declared using var keyword as shown below:
```
var ivariable = 10; 
```
In implicitly typed variables, you are not allowed to declare multiple var in a single statement as shown below:
```
 var ivalue = 20, a = 30; // invalid
```
It is not allowed to use var as a field type in class level.
It is allowed to use the expression in var like:
```
Var b;
b -= 39; 
```
In C#, one cannot declare implicitly typed variable without any initialization like:
```
 var ivalue;   // invalid
```
It is not allowed to use a null value in implicitly typed variable like:
```
 var value = null;   // invalid
```
The initializer cannot contain any object or collection, it may contain a new expression that includes an object or collection initializer like:
```
// Not allowed
var data = { 23, 24, 10};

// Allowed 
var data = new int [] {23, 34, 455, 65};
```

It is not allowed to initialize implicitly typed variable with different types more than one type like:

// It will give error because
// the type of the value is different
// one is of string type and another
// one is of int type
var value = "sd" 
value = new int[]{1, 2, };

Example 1

// C# program to illustrate the
// concept of implicitly typed variable
using System;

public class GFG {

    // Main method
    static public void Main()
    {

        // Declaring and initializing 
        // implicitly typed variables
        var a = 50;
        var b = "Welcome! Geeks";
        var c = 340.67d;
        var d = false;

        // Display the type of the variables
        Console.WriteLine("Type of 'a' is : {0} ", a.GetType());

        Console.WriteLine("Type of 'b' is : {0} ", b.GetType());

        Console.WriteLine("Type of 'c' is : {0} ", c.GetType());

        Console.WriteLine("Type of 'd' is : {0} ", d.GetType());
    }
}

Output

Type of 'a' is : System.Int32 
Type of 'b' is : System.String 
Type of 'c' is : System.Double 
Type of 'd' is : System.Boolean

Example 2

// C# program to illustrate the
// use of implicitly typed variable
using System;

class GFG {

    // Main method
    static public void Main()
    {

        // explicitly typed variables
        int Base = 13;
        int Height = 20;
        int Area = (Base * Height) / 2;

        // Display result
        Console.WriteLine("Height of triangle is: " + Height 
                      + "\nBase of the triangle is: " + Base);

        Console.Write("Area of the triangle is: {0}", Area);
    }
}

Output

Height of triangle is: 20
Base of the triangle is: 13
Area of the triangle is: 130

Note: Implicitly typed local variables can be used as a local variable in a function, in foreach, and for loop, as an anonymous type, in LINQ query expression, in using statement etc.

Article Tags :

CSharp-Basics