C# 'var' keyword versus explicitly defined variables

Question

I'm currently using ReSharper's 30-day trial, and so far I've been impressed with the suggestions it makes. One suggestion puzzles me, however.

When I explicitly define a variable, such as:

List<String> lstString = new List<String>();

ReSharped adds a little squiggly green line and tells me to:

Use implicitly type local variable declaration.

If I then follow its suggestion, ReSharper changes the line of code to:

var lstString = new List<String>();

So, is there some sort of performance gain to be had from changing the List<String> to a var, or is this merely a peculiarity of ReSharper? I've always been taught that explicitly defining a variable, rather than using a dynamic, is more optimal.

Answer 1

Nope. They emit the exact same IL.

It's just a matter of style.

var has the benefit that makes it easier for you to change the return type of functions without altering other parts of source code. For example change the return type from IEnumerable<T> to List<T>. However, it might make it easier to introduce bugs.

Answer 2

var is different than dynamic keyword, also compiler will convert var keywords to actual type handle

Answer 3

The var keyword does not actually declare a variable with a dynamic type. The variable is still statically typed, it just infers the type from the context.

Its a nice shortcut when you have a long typename (generic typenames can be long)

Answer 4

Also see this question specifically regarding var use in ReSharper.

Answer 5

So, is there some sort of performance gain to be had from changing the List to a var

No but this is not the only valid reason for a refactoring. More importantly, it removes redundance and makes the code shorter without any loss in clarity.

I've always been taught that explicitly defining a variable, rather than using a dynamic, is more optimal.

You misunderstand what var means. This is not in any way dynamic, since it produces the same output. It just means that the compiler figures the type for the variable out by itself. It's obviously capable of doing so, since this is the same mechanism used to test for type safety and correctness.

It also removes a completely useless code duplication. For simple types, this might not be much. But consider:

SomeNamespace.AndSomeVeryLongTypeName foo = new SomeNamespace.AndSomeVeryLongTypeName();

Clearly, in this case doubling the name is not just unnecessary but actually harmful.

Answer 6

Less typing = more productivity :)