When should you use the 'var' keyword in C#?

var list = new List<string>();  // list inferred to be of type List<string>
var count = 3;  // count inferred to be of type int
var greeting = "Hello";  // greeting inferred to be of type string
var varChar = 'c'; // varChar (as an ordinary identifier) inferred to be of type char

var anonymous = new { FirstName = "John", LastName = "Doe" };
var query = from name in names
            where name.StartsWith("A")
            select new { Initial = name[0], LastName = name.Split(' ')[1] };

When can't var be used?

Its use is restricted to declaring local variables within methods or properties, including iteration variables in 'for' or 'foreach' statements. This means that it can't be used in any of the following scenarios.

• As the type of field.
• As the type of parameter.
• As the return type of a method or property.
• As a type parameter in a generic type or method.

It also can't be used if there's a type called 'var' within the same scope.

class Program
{
    static void Main()
    {
        var v = "Hello"; // Type of 'v' will be inferred as 'string'
    }
}

Nor, can it be used in statements like this where the type of 'var' cannot be inferred.

var n = null; // Cannot assign <null> to an implicitly-typed local variable

When should var be used?

So, for those of us who are not committed one way or the other to the use of 'var', is there a sensible middle ground that most of us could agree upon.

The main objection to the indiscriminate use of 'var' is that it makes code harder to read because you can't tell just by inspection what the type of the variable is - you have to think about it first and may be struggling even then.

This suggests that it would be reasonable to confine the use of 'var' to those cases where the type is obvious because it explicitly appears on the right hand side of the assignment. These cases would include.

• 'new' expressions.
• 'static' methods, which return a value of the same type.
• Expressions involving a simple cast.
• Expressions include an 'as' conversion.

Here are some examples.

using System;
using System.Collections;
class Program
{
    static void Main()
    {
        var ht = new Hashtable();
        var dt = DateTime.Parse("1/1/2011");
        ht.Add(1, dt);
        var dt2 = (DateTime)ht[1];
        var dict = ht as IDictionary;
    }
}

Now you could argue in all these cases that you might not necessarily be assigning these values to a variable of the 'obvious' type but to a variable of a type to which the obvious type is implicitly convertible (say, 'object' in the above cases). However, if that were the case, then there would be nothing to stop you from specifying the type of the variable explicitly, as you would already have a mixture of implicit and explicit assignments if you followed these conventions.

Even if you accept these restrictions as reasonable, you then have to decide how long a type name needs to be for the saving in typing, line length, and duplication to be worthwhile. I think you could certainly say that it would be worthwhile for any generic type but what about non-generic types.

Although it's highly subjective, my own view is that it's not worthwhile unless the name of the non-generic type consists of at least eight characters which conveniently excludes the built-in types (string, double, decimal, etc.) from consideration.

Does it really matter what you do?

Yes, I believe it does.

When you're writing code, you don't want to be agonizing over whether you should be using 'var' or not! You need a clear policy on when (if at all) you should use it, so the decision can be made instantly.

Similarly, when you're reading code, you don't want to spend several seconds trying to decide what the type of a variable is - you should be able to tell instantly.

Although, if you were previously uncommitted, you may not necessarily agree with my 'sensible middle ground' proposal, I hope this article will at least help you to decide on a policy which is right for you.