var keyword in C# 3.0

Question

Possible Duplicate:
What’s the point of the var keyword?

Hello everyone,

I want to confirm whether my understanding is correct. If I do not use LINQ, then the only benefit of using var is to make brevity? Is that correct understanding?

thanks in advance, George

Answer 1

No, you can use var to construct anonymous types, regardless of whether or not you're using LINQ:

var anon = new { Name = "Anonymous", Age = 42 };

Answer 2

It's also easier for working with types like this. When you have very long generic types, the type name can get in the way of visually identifying the variable name as part of a declaration.

Dictionary<string, Dictionary<int, ICollection<object>>>

especially if you go back through and change it to

Dictionary<string, IDictionary<int, ICollection<object>>>

Answer 3

I believe it is also used in the WCF (Windows communication Foundation) when dealing with data obtained via webservices and the like.

Answer 4

If you're not using LINQ, var allows you to only declare the type of the variable once, instead of twice.

Example

var myObject = new MyObject();

vs

MyObject myObject = new MyObject();

This can only be done locally, and is also useful for declaring anonymous types.

Example

var myAnon = new { Name = "Something", Count = 45 };

Answer 5

Pretty much, yes. var may be used wherever the compiler can infer the type of the variable from whatever value you are assigning to it. (The type inference rules are quite complex however, so you may want to read the C# specification for a full understandin.)

It's not quite correct in that the var keyword is required for defining anonymous types. For example:

var foo = new { abc = 1, def = 2 };

which can be used outside of LINQ queries as well as inside, of course.

Answer 6

From msdn:

Beginning in Visual C# 3.0, variables that are declared at method scope can have an implicit type var. An implicitly typed local variable is strongly typed just as if you had declared the type yourself, but the compiler determines the type. The following two declarations of i are functionally equivalent:

var i = 10; // implicitly typed
int i = 10; //explicitly typed

MSDN Link Here

Answer 7

Other than for LINQ queries I would be very cautious in using the var keyword. There are specific instance when you just need an anonymous type but this is few and far between I think. Var can lead to very confusing code as you have no idea what the type you are dealing with when reading the code unless you use the intellisense crutch.

It worries me more and more that I see so many snippets and bits of code that do the following... it's lazy and not what the var keyword was intended for:

// Not too bad but still shouldn't be done because the only gain you have is keystrokes
var Something = new SomeObject();

// Type here is not obvious, are you getting an int, double, custom object back???
var Something = GetLengthOfSpaghettiCode();

So use it for LINQ... use it for anonymous types (if you do use anonymous types outside of LINQ you should really scrutinize why you need to).

Quote from MSDN (very last line of article) regarding use of var:

However, the use of var does have at least the potential to make your code more difficult to understand for other developers. For that reason, the C# documentation generally uses var only when it is required.

Don't use it as a short cut to save keystrokes, the next guy looking at your code will appreciate it.

Answer 8

I've also found that the use of var also eases refactoring in low-coupled designs. This is because we tend to strong type variables, but normally the code that follows is expecting weaker types. Using var you'll offset type changes to the compiler.

Answer 9

I don't think using var should be a problem - and I prefer it for exactly the reasons of code readability. First of all, var is only syntactic sugar and just gets compiled away to a proper type when IL is emitted. And as far as the code readability goes, it makes more sense to focus on the purpose the variable is used for, and how it is assigned than just its type. VS .NET editor shows the type in the line following it anyway - if you just hover on it. So this shouldn't be a problem at all. And as far as the debugging goes - if you see Autos/Local/Watch windows - they display the types of all the members.

It makes more sense for me to see code like this:

var customers = GetCustomerList();
foreach (var customer in customers)
{
  customer.ProcessOrders();
}

as opposed to

List<CustomerObjectDeserializedFromWebService> customers = GetCustomers();
foreach (CustomerObjectDeserializedFromWebService customer in customers)
{
  customer.ProcessOrders();
}

var is in its fairness limited to using in local variable declarations which are also initialized at the time of declaration. And in that one case, if you omit the actual type it definitely improves readability IMO.

EDIT: And it would unfair on my part not to warn against the usages as below:

var x = 20;

This is not good; when the literal is applicable to multiple types, you need to know the default type of the literal and hence understand what is infered for the type of x. Yes, by all means, I would avoid such declarations.