Type inference != Dynamic typing

Local variable type inferencing is a new feature in C# 3.5 – a very “handy” one, in that it saves a lot of typing. Basically, it lets you do 

var dict = new Dictionary<string, List<int, Dictionary<int, string>>>();

instead of 

Dictionary<string, List<int, Dictionary<int, string>>> dict = Dictionary<string, List<int, Dictionary<int, string>>>();

That’s pretty cool, but remember, C# is still a statically typed language. dict is statically bound to the type Dictionary<string, List<int, Dictionary<int, string>>> and you cannot change it. You cannot do

dict = Dictionary<int, string>();

in the same method. The compiler will complain that the type on the RHS is not convertible to the statically bound type of dict.

Contrast this to a dynamically typed language like Javascript, which also uses the var keyword to declare variables. 

var x = 1;
x = new Array();
x = "23";

Or to Python 

x = 42
x = def fn(z) : return z + 1

In such languages, variables (x, in our example) simply act as placeholders and get bound to the type of the value they are holding at the moment. In the first example, x is holding an integer after executing the first line. After executing the second line, it’s holding an array. If the same two lines of code were to be written in a statically typed language, the second line would be correct only if an array is somehow convertible to an int.

The point of the post – don’t be misled by the var keyword. The variable it declares is still a good old statically typed variable.