Under what assumption does Re-Sharper shows me "Use implicitly typed local variable" message?

Question

In my understanding C# started as a static language and with some enhancements in the .NET framework and started supporting the dynamic nature of the language.

I think the "var" keyword in c# is very powerful when it comes to loading the DLLs at the runtime and we do not know the types coming our way, it is very helpful.

But I think it brings the overhead of determining the type of the variable if the variable has been declared as a var at design-time. Now, re-sharper which is responsible for making our code much more nicer and cleaner by doing some nice suggestions has suggested me something like below:

My code looks like this:

StatusResult result = new StatusResult();

Resharper suggests that it has to be converted into

 var result = new StatusResult();

Why is that? why should I buy resharper's suggestion when I think that it is not a good idea? Or may be I am wrong?

Answer 1

As to your question,

Why is that? why should I buy resharper's suggestion when I think that it is not a good idea?

Here is my opinion from my experience. Some pro's of accepting this particular suggestion:

• It aids in refactoring because StatusResult only occurs once
• It shortens the line and removes a redundant declaration that is easily inferred by someone reading the code
• It is less typing and the line is written faster when coding

Now, if the line of code was:

var result = GetStatusResult();  // A method call

I personally would not use var because a maintainer now needs to grok GetStatusResult() to see what var is.

At the end of the day it is a personal decision, unless you have to follow a coding standard, in which case you should lobby to change the standard or just go along with it.

As a side note, and as Benesh mentions below, var != dynamic. I think this is where var get's a bad rap. Plus the overuse in the example of when not to use it I provided above.

Answer 2

This is mostly an opinion-based question, but there's one issue worth addressing: it is very important to distinguish type inference from dynamic typing.

In dynamic i = 0; , i is declared as a dynamic variable, whose type is only resolved in run time. It may result in an overhead.

In var i = 0; i is declared as an int. The var keyword means only that the variable type will be inferred by the compiler at compile time. There's no "design-time" type inference overhead, since var i = 1; and int i = 1 compiles to the same set of instructions. It's got nothing to do with dynamic typing.