If you are from VC++, COM background, this keyword is somewhat similar to variant that we used in COM programming. Var is an implicit type. C# 3.0 introduces anonymous types. Since anonymous types by definition have no names, you need to be able to infer the type of the variable from the initializing expression if its type is anonymous. So Var aliases any type in the C# programming language. The aliased type is determined by the C# compiler. 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.
Some of the uses of Var keyword:
It induces better naming for local variables.
It induces better API.
It induces variable initialization.
It removes code noise
It doesn’t require the using directive.
Some cases where it seems just fine to suggest var are:
New object creation expression: var dictionary = new Dictionary<int, string>();
Cast expression: var element = (IElement)obj;
Safe Cast expression: var element = obj as IElement;
Generic method call with explicit type arguments, when return type is generic: var manager = serviceProvider.GetService<IManager>()
Generic static method call or property with explicit type arguments, when return type is generic: var manager = Singleton<Manager>.Instance;
Local variables can be given an inferred “type” of var instead of an explicit type. The var keyword instructs the compiler to infer the type of the variable from the expression on the right side of the initialization statement. The inferred type may be a built-in type, an anonymous type, a user-defined type, or a type defined in the .NET Framework class library. The var keyword can represent any type that can be determined at compile-time. It is precisely equivalent after compilation.
The C# language reference: Overuse of var can make source code less readable for others. It is recommended to use var only when it is necessary, that is, when the variable will be used to store an anonymous type or a collection of anonymous types.
Below is more difference from MSDN:
The keywords var and dynamic are only apparently similar. Var indicates that the type of the variable has to be set to the compile-time type of the initializer.
But dynamic means that the type of the variable is the dynamic type as available in C# 4.0. In the end, dynamic and var have quite opposite meanings. Var is about reinforcing and improving static typing. It aims to ensure that the type of a variable is inferred by the compiler looking at the exact type being returned by the initializer.
The keyword dynamic is about avoiding static typing altogether. When used in a variable declaration, dynamic instructs the compiler to stop working out the type of the variable at all. The type has to be intended as the type it happens to have at run time. With var, your code is as statically typed as it would have been had you opted for the classic approach of using explicit types in a variable declaration.
Another difference between the two keywords is that var can only appear within a local variable declaration. You can’t use var to define a property on a class, nor can you use it to specify the return value or a parameter of a function.
As a developer, you use the dynamic keyword with variables expected to contain objects of uncertain type such as objects returned from a COM or DOM API; obtained from a dynamic language (IronRuby, for example); from reflection; from objects built dynamically in C# 4.0 using the new expand capabilities.
The dynamic type doesn’t bypass type checks, though. It only moves them all to run time. If type incompatibilities are discovered at run time, then exceptions are thrown.
For more information, see http://msdn.microsoft.com/en-us/magazine/ee336309.aspx