Use of var keyword in C#

Answer 1

Neither of those is absolutely true; var can have both positive and negative effects on readability. In my opinion, var should be used when either of the following is true:

1. The type is anonymous (well, you don't have any choice here, as it must be var in this case)
2. The type is obvious based upon the assigned expression (i.e. var foo = new TypeWithAReallyLongNameTheresNoSenseRepeating())

var has no performance impacts, as it's syntactic sugar; the compiler infers the type and defines it once it's compiled into IL; there's nothing actually dynamic about it.

Answer 2

I split var all over the places, the only questionable places for me are internal short types, e.g. I prefer int i = 3; over var i = 3;

Answer 3

None, except that you don't have to write the type name twice. http://msdn.microsoft.com/en-us/library/bb383973.aspx

Answer 4

I think the use of var should be coupled with wisely-chosen variable names.

I have no problem using var in a foreach statement, provided it's not like this:

foreach (var c in list) { ... }

If it were more like this:

foreach (var customer in list) { ... }

... then someone reading the code would be much more likely to understand what "list" is. If you have control over the name of the list variable itself, that's even better.

The same can apply to other situations. This is pretty useless:

var x = SaveFoo(foo);

... but this makes sense:

var saveSucceeded = SaveFoo(foo);

Each to his own, I guess. I've found myself doing this, which is just insane:

var f = (float)3;

I need some sort of 12-step var program. My name is Matt, and I (ab)use var.

Answer 5

One specific case where var is difficult: offline code reviews, especially the ones done on paper.

You can't rely on mouse-overs for that.

Answer 6

It can certainly make things simpler, from code I wrote yesterday:

var content  = new Queue<Pair<Regex, Func<string, bool>>>();
...
foreach (var entry in content) { ... }

This would have be extremely verbose without var.

Addendum: A little time spent with a language with real type inference (e.g. F#) will show just how good compilers are at getting the type of expressions right. It certainly has meant I tend to use var as much as I can, and using an explicit type now indicates that the variable is not of the initialising expression's type.