Tutorialspoint.dev

C# | Implicitly Typed Local Variables – var

Implicitly typed variables are those variables which are declared without specifying the .NET type explicitly. In 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 situation 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 defining it at class level etc. because the scope of the implicitly typed variable is local.

Example:

// 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:

  • 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-=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()
    {
  
        // implicitly typed variables
        var Base = 13;
        var Height = 20;
        var Area = (Base * Height) / 2;
  
        // Display result
        Console.WriteLine("Height of triangle is: " + Height 
                      + " Base of the tringle is: " + Base);
  
        Console.Write("Area of the tringle is: {0}", Area);
    }
}

Output:

Height of triangle is: 20
Base of the tringle is: 13
Area of the tringle 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.



This article is attributed to GeeksforGeeks.org

leave a comment

code

0 Comments

load comments

Subscribe to Our Newsletter