What advantages does using var have over the explicit type in C#?

Question

Possible Duplicates:
What’s the point of the var keyword?
Use of var keyword in C#

I understand how IEnumerable<...> for a datatype can make the code a little less readable or how nested generics can seem a little daunting. But aside from code readability, are there advantages to using var instead of the explicit type? It seems like by using the explicit type, you'd better convey what the variable is capable of because you know what it is.

If it's a workplace coding standard, I use it for the sake of teamwork. In my own projects however, I prefer to avoid the user of var.

Answer 1

It produces no meaningful change in the emitted IL. It is merely a code style preference.

I, for one, like it, especially when dealing with types that have long, generic, almost unreadable names such as Dictionary<string, IQueryable<TValue1, TValue2>>[].

Answer 2

I like it, especially in unit tests, because as the code evolves I only have to fix up the right-hand side of the declaration/assignment. Obviously I also have to update to reflect the changes in usage, but at the point of declaration I only have to make one change.

Answer 3

The var is just a syntactic sugar. It is always known at compile time what type the variable is. There are no other advantages of using the var keyword.

Answer 4

Using var as the iterator variable for a foreach block is more type safe than explicit type names. For example

class Item {
  public string Name; 
}
foreach ( Item x in col ) {
  Console.WriteLine(x.Name);
}

This code could compile without warnings and still cause a runtime casting error. This is because the foreach loop works with both IEnumerable and IEnumerable<T>. The former returns values typed as object and the C# compiler just does the casting to Item under the hood for you. Hence it's unsafe and can lead to runtime errors because an IEnumerable can contain objects of any type.

On the other hand the following code will only do one of the following

1. Not compile because x is typed to object or another type which does not have a Name field / property
2. Compile and be guaranteed to not have a runtime cast error while enumerating.

The type of 'x' will be object in the case of IEnumerable and T in the case of IEnumerable<T>. No casting is done by the compiler.

foreach ( var x in col ) {
  Console.WriteLine(x.Name);
}

Answer 5

There aren't any real differences. Some people suggest using the explicit type because it can make maintaining the code easier. However, people that push for var have the stance that "if we use var, we are forced to use good naming conventions".

Of course if you use vars with the intention of having good naming conventions and that breaks down, it's more painful down the road. (IMO)

Answer 6

Besides the readability aspect you mentioned, 'var' also has the benefit of reducing the probability that a trivial code change will break other parts of your code. If you rename a type, for example. Or if you switch to a different type that is mostly compatible with the former type (e.g. changing from Foo[] to IEnumerable) you have much less work to do to get your code back to a compilable state.

Answer 7

The point of var is to allow anonymous types, without it they would not be possible and that is the reason it exists. All other uses I consider to be lazy coding.

Answer 8

public IAwesome { string Whatever { get; } }
public SoCool : IAwesome { public string Whatever { get; } }

public HeyHey
{
    public SoCool GetSoCool() { return new SoCool(); }

    public void Processy()
    {
        var blech = GetSoCool();
        IAwesome ohYeah = GetSoCool();
        // Now blech != ohYeah, so var is blech and ohYeah is IAwesome.
    }
}

Answer 9

You can abstract away the mental complexity of the technicalities to focus purely on the problem domain from your model. you have to make sure your variables are named meaningfully tho.