Shahin Alborz – EPiServer & ASP.NET developer

There is always a lot of talk about coding conventions and best practices, and with C# 3.0 came implicitly typed local variables which enables the var keyword to be used when declaring variables. The variable will in fact be strongly typed. The compiler takes care of that by determining the appropriate type. The question is in which cases should we use var instead of the usual explicit declaration?

As many things, this is somewhat a matter of taste. That is, unless we’re talking about anonymous types (for instance when using LINQ) in which case you have to use var. Generally, there are three different camps regarding this. Some don’t use var unless they have to, some use it only when the type is obvious, and others use it all the time.

Let’s go through the pros and cons:

What are the benefits of using var

• Dont Repeat Yourself (DRY) – Redundant code should be avoided.
• Faster creation of code
• Calls for improved naming of variables – can work as a reminder for descriptive naming
• Improved readability – in some cases (where the repeated type is long and complex)
• Less code modification if you later need to change the type
• Clearer distinction of when you really want to specify the type

The disadvantages of using var

• Loss of readability – in some cases (where the type isn’t obvious)
• Changes to the type could introduce bugs which the compiler otherwise would have caught for the developer

The main argument for not using var is usually loss of readability. Let’s take a further look at that. Consider the following:

1

Dictionary<string, List<string>> myDictionary = new Dictionary<string, List<string>>();

Or…

1

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

Which do you find more easy to read? Let’s not forget about intellisense by the way, which you often have to use anyway.

Obviously there are situations where the contrary applies, but repeating complex types seems redundant and I see no benefits doing so. On the other hand, I find it unnecessary to use var for primitive types such as int or string.

As for the compiler not complaining after the type has been changed – by avoiding the use of var in such situations, for instance when declaring a variable in a for-loop declaration, you should be safe anyway. In some cases it’s even safer to use var in for-each loops as it could force you to write an explicit cast.

What about consistency and clear guidelines?
Organisations usually prioritize consistency and simple, clear guidelines over all of the pros and cons listed above, which probably will result in guidelines to advocate one of the two extremes regarding this; never to use implicit variable declarations – or use it everywhere. That means the ideal theory will be ignored.

Conclusion:
In my opinion the var keyword should certainly be used with care, but redundant declarations should be avoided. Therefore it would be preferred to use implicit declarations wherever it’s appropriate, i.e where the type is clear and obvious. Consistency shouldn’t be neglected, but I believe developers in the an organisation would identify the same situations where the type is ambigous.

In the end it’s really about finding a sensible balance. If keeping in mind to use var to avoid repetition and obvious type declarations, the answer is pretty clear of when to var or not… where the type is reasonably obvious.

What are your preferences? Leave your replies in the comments section!

Here are a couple of good/bad examples based on a reasonable usage of implicit variable declaration…

+ Good:
var numbers = new int[] {1, 2, 3, 4};
var stringbuilder = new StringBuilder();
var cars = new List();
var orders = new Dictionary();

+/- OK with either (but prefer explicit declaration):
int pages = 10;
string username = “john”;
var username = “john”;
var order = GetOrder(orderId); // ok if the type is Order, otherwise not
for (var x = 1; x < 10; x++)

– Bad:
var settings = GetInboxSettings(); // not obvious at all
var userId = GetUserId(); // ambigous, is this guid or int?
Dictionary orders = new Dictionary(); // redundant

This entry was posted on Thursday, January 13th, 2011 and is filed under Uncategorized. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.