When to use var keyword in C#


Microsoft introduced “var” keyword in C# 3.0. The purpose of using this keyword is when you don’t know type of variable. The technical term for var is "implicitly typed local variable declaration". The variable itself is still statically typed (the type is determined when the code is compiled), and it is still strongly typed (the type cannot change once it has been declared). the compiler infers the type of the variable based upon the initialize for the variable. It is mainly use in anonymous methods, LINQ etc. Some of the programmers use this variable frequently in declaration. Below is some examples how to use var:

 
//this will compile as Hotel class
 var list = from hotel in this.Hotels
	 where (hotel.City.Contains(searchCriteria))
	 orderby hotel.Id
	 select hotel;

 // i is compiled as an int
 var i = 5;

 // s is compiled as a string
 var s = "Hello";

 // a is compiled as int[]
 var a = new[] { 0, 1, 2 };

 // expr is compiled as IEnumerable
 // or perhaps IQueryable
 var expr =
    from c in customers
    where c.City == "London"
    select c;

 // employee is compiled as an anonymous type
 var employee = new { Name = "Neeraj", Age = 31 };

Benefits of using Var

  • It removes code noise eg. redundant code in declaration of generics.

  • It doesn’t require using directive.

  • Most obvious use in LINQ and Anonymous type.

Restrictions of using Var

  • var can only be used when a local variable is declared and initialized in the same statement; the variable cannot be initialized to null, or to a method group or an anonymous function.

  • var cannot be used on fields at class scope.

  • Variables declared by using var cannot be used in the initialization expression. In other words, this expression is legal:

int i = (i = 20);

but this expression produces a compile-time error:

var i = (i = 20);
  • Multiple implicitly-typed variables cannot be initialized in the same statement.

  • If a type named var is in scope, then the var keyword will resolve to that type name and will not be treated as part of an implicitly typed local variable declaration.

  • It must not return the null type.

  • It must not refer to the variable being declared. 

NOTE: Overuse of var can make source code less readable for others.It is recommended to use var only when it is necessary, that is, when the variable will be used to store an anonymous type or a collection of anonymous types.

var amount = Account.GetBalance(); // it can return double, decimal etc. //but as per code we are not sure what would be return type.

Microsoft’s C# language reference page for var also warns about the consequences of using var everywhere.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Powered by WordPress.com.

Up ↑

%d bloggers like this: