Advantage of var keyword in C# 3.0 [duplicate]

Answer 1

In short:

1. minimize the need for typing the variable type twice
2. essential in supporting anonymous types, e.g. as returned by LINQ queries

Answer 2

• Linq expressions don't return a predefined type, so you need a 'generic' variable declaration keyword to capture that and other places where anonymous types are used.
• Used carefully, it can make refactoring easier by decoupling a method's return type from the variable that captures it.
• Having to put the same name on the same line twice for the same statement is really kind of silly. It's a pain to type something like this:

.

ReallyLongTypeName<SomeOtherLongTypeName> MyVariable = new ReallyLongTypeName<SomeOtherLongTypeName>();

Answer 3

It's a shorthand way of declaring a var. Although "int i = new int()" isn't too much to type, when you start getting to longer types, you end up with a lot of lines that look like:

SomeReallyLong.TypeName.WithNameSpaces.AndEverything myVar = new SomeReallyLong.TypeName.WithNameSpaces.AndEverything();

It eventually occurred to someone that the compiler already knew what type you were declaring thanks to the information you were using to initialize the var, so it wouldn't be too much to ask to just have the compiler do the right thing here.

Answer 4

It's mostly present for LINQ, when you may use an anonymous type as the projection:

var query = from person in employees
            where person.Salary > 10000m
            select new { FullName=person.Name, person.Department };

Here the type of query can't be declared explicitly, because the anonymous type has no name. (In real world cases the anonymous type often includes values from multiple objects, so there's no one named class which contains all the properties.)

It's also practically useful when you're initializing a variable using a potentially long type name (usually due to generics) and just calling a constructor - it increases the information density (reduces redundancy). There's the same amount of information in these two lines:

List<Func<string, int>> functions = new List<Func<string, int>>();
var functions = new List<Function<string, int>>();

but the second one expresses it in a more compact way.

Of course this can be abused, e.g.

var nonObviousType = 999999999;

but when it's obvious what the type's variable is, I believe it can significantly increase readability.

Answer 5

Here are a couple of advantages

1. Less typing with no loss of functionality
2. Increases the type safety of your code. A foreach loop using an iteration variable which is typed to var will catch silently casts that are introduced with explicit types
3. Makes it so you don't have to write the same name twice in a variable declaration.
4. Some features, such as declaring a strongly typed anonymous type local variable, require the use of var

Shameless self promotion. I wrote a blog entry on this subject awhile back that dived into when I thought the use of var was appropriate and contains relative information to this topic.

• http://beta.blogs.msdn.com/jaredpar/archive/2008/09/09/when-to-use-type-inference.aspx

Answer 6

The primary reason for its existence is the introduction of anonymous types in C#. You can construct types on the fly that don't have a name. How would you specify their name? The answer: You can't. You just tell the compiler to infer them for you:

var user = users.Where(u=> u.Name == "Mehrdad")
                .Select(u => new { u.Name, u.Password });