C# Var Keyword

In c# 3.0, the var keyword has been introduced to declare the implicitly typed local variables without specifying an explicit type and the type of local variables will automatically determine by the compiler based on the right side value of initialization statement.

 

Following two declarations are functionally equivalent in c#.

 

var x = 50; // Implicitly typed

int y = 50; // Explicitly typed

The above two declarations are functionally equivalent. As discussed, the compiler will automatically infer the type “integer” to the variable x based on the right side value 50.

C# Var Keyword Example

Following is the example which will show the various ways of declaring the implicitly typed local variables with var keyword in c#.

 

using System;

 

namespace TutlaneExamples

{

    class Program

    {

        static void Main(string[] args)

        {

            var i = 100;

            Console.WriteLine("i value: {0}, type: {1}", i, i.GetType());

            var j = "Welcome to Tutlane";

            Console.WriteLine("j value: {0}, type: {1}", j, j.GetType());

            var k = true;

            Console.WriteLine("k value: {0}, type: {1}", k, k.GetType());

            var l = 20.50;

            Console.WriteLine("l value: {0}, type: {1}", l, l.GetType());

            Console.ReadLine();

        }

    }

}

If you observe the above example, we declared and initialized the implicitly typed local variables with different values and the compiler will automatically determine and assign the most appropriate type based on the assigned value.

 

When we execute the above example, we will get the result like as shown below.

 

i value: 100, type: System.Int32

j value: Welcome to Tutlane, type: System.String

k value: True, type: System.Boolean

l value: 20.5, type: System.Double

In above example, we used var keyword to declare the variables at method level but we can also use the var keyword in for, foreach and using statements like as shown below.

 

**** for loop ****

for (var i = 1; i < 10; i++)

{

// your code

}

**** foreach loop ****

foreach (var item in list)

{

// your code

}

**** using statement ****

using (var sr = new StreamReader(@"D:\Test.txt"))

{

// your code

}

Generally, in many cases the use of var is an optional but while working with the anonymous types, we must need to declare the variables with var like as shown below to access the properties of an object and it’s a common scenario in LINQ query expressions.

 

// Create anonymous type object

var userInfo = new

{

  Id = 1,

  Name = "Suresh Dasari",

  IsActive = true

};

// Access anonymous type object properties

Console.WriteLine("Id:" + userInfo.Id);

Console.WriteLine("Name:" + userInfo.Name);

Console.WriteLine("IsActive:" + userInfo.IsActive);

C# Var Variable Restrictions

In c#, while creating implicitly-typed local variables we need to make sure that the variable is declared and initialized in the same statement otherwise we will get a compile-time error and the variable cannot be initialized with a null value.

 

var x = 10; // valid

var y; y = 10; // Error: Implicitly-typed variables must be initialized

var z = null; // Error: Cannot assign null to implicitly typed variable

In c#, implicitly-typed variables cannot be used as method parameters and we should not initialize multiple implicitly-typed variables in the same statement.

 

var x = 10, y = 20, z = 30; // Invalid: Compile-time Error

var x = 10; // valid

var y = 20; // valid

var z = 30; // valid

// var variable as function Parameter

void GetDetails(var x) // Invalid: Compile-time error

{

// your code

}

Same way, we are not allowed to use implicitly-typed variables in initialization expressions like as shown below.

 

int x = (x = 20); // valid

var y = (y = 20); // invalid

C# Var Keyword Overview

Following are the important points which we need to remember about var keyword in c#.

 

  • var keyword is useful to declare the implicitly-typed local variables without specifying an explicit type.
  • In c#, the type of implicitly-typed local variables will automatically determine by the compiler based on the right side value of the initialization statement.
  • The var variables must be declared and initialized in the same statement.
  • We are not allowed to assign a null value to the implicitly-typed local variables.
  • Multiple implicitly-typed variables cannot be initialized in the same statement.
  • var is not allowed to use as a field type at the class level.
 
 

NEXT

C# Dynamic Type  
 

Topics Covered