Posted by: jsonmez | May 5, 2010

Do You Have a Case of var Guilt?

Ever since var was announced as a keyword for C# 3.0, I have had issues with it.

I know that it is strongly typed, but something just felt wrong about it.  It felt like some kind of an abomination.

Perhaps I just like to repeat myself = new Perhaps I just like to repeat myself.

Finally, I started using var, because I don’t know what the heck a LINQ query returns.  I just know that if I put var at my variable declaration before my LINQ query, it just works.  Then if I put var before my variable in my foreach loop, that just works too.

Reluctantly I started using var, but every time I did I would start to feel guilty.  Like I did something wrong.  Like I was a bad person.  Like I was writing strongly typed VB code.  I felt dirty.

Be clean my sons!  Throw off your shackles!

I contemplated the issue for a good long while.  It has been months that this var issue has been eating me, slowly leaking into my code.  Then, I had an epiphany!

var is just an abstraction.  I don’t need to know the type of variables as long as the compiler does.

There is no need to feel guilty when using var.  It is preventing the reader of your code from focusing on the types of the variables and instead focusing on the purpose of the variables.

I rewrote some code using var wherever possible to see if it decreased readability at all. (I took it to the extreme)

public string reverse(string toReverse)
    var reversed = "";
    var lastCharacterIndex = toReverse.Length -1;
    var firstCharacterIndex = 0;
    for(var index = lastCharacterIndex; index >= firstCharacterIndex; index--)
        var letter = toReverse[index];
        reversed += letter;

    return reversed;

Admittedly, it looks a little strange.  But honestly, is it any more difficult to read than if I had put all the types in there instead of var?  Does that actually give you any useful information that helps you understand this code?  As long as my variable names are good, I would venture to say that the readability is improved, because anything that adds information that is not important to the code is a distraction.

Bonus: decoupling

As I was contemplating this issue, I realized something more than aesthetics pushed me to the var side of the force.  var is reducing coupling in my code when I use it.

If I call a method that returns some object in my code, but I hold the reference to it with a variable I declared using var, if that method changes to return something else with similar usage, I won’t have to change the source code.  (I will have to recompile though.) In many instances var can serve as a bonus to slightly decouple your application in places where methods return concrete types.  Every little bit helps.

Anything that reduces your dependency on concrete types, and makes your code more flexible while still catching issues at compile time instead of runtime, is good in my book.

Hinging on the IDE

There is one caveat here.  This all depends on the IDE.  You have to have intellisense and auto-complete, otherwise this whole thing falls apart.  I don’t need to know the underlying type, because I can just hit “.” on my keyboard and Visual Studio tells me what my options are.  I can go back and figure out what the type is by just hovering over the var declaration in Visual Studio.

Without those abilities, var would not be as good.  Without those capabilities you would have to go back to where the variable was declared, and possibly trace up a method call to figure out the return type to know what type the var variable will be initialized to.

As always, you can subscribe to this RSS feed to follow my posts on Making the Complex Simple.  Feel free to check out where I post about the topic of writing elegant code about once a week.  Also, you can follow me on twitter here.


  1. […] Do You Have a Case of var Guilt? – John Sonmez talks about the guilt he first felt when using the var keyword in C#, and shares how his feelings changed as he realised that var, as well as being shorter to type, actually helped reduce his dependency on concrete types therefore affording some looser coupling in his applications […]

  2. So, why not:

    01 public string reverse(string toReverse)
    02 {
    03 reversed = “”;
    04 lastCharacterIndex = toReverse.Length -1;
    05 firstCharacterIndex = 0;
    06 for(index = lastCharacterIndex; index >= firstCharacterIndex; index–)
    07 {
    08 letter = toReverse[index];
    09 reversed += letter;
    10 }
    12 return reversed;
    13 }

    • Did you just javascript rick roll me? Actually it is pretty interesting to look at it that way without even having the vars. Is the value in immediately knowing on a line if a variable is being delared or not? I’m not sure.

  3. Nice. I can relate to feeling this way at first too. Now it’s time to change your ‘Email Me’ section to use var for your stringbuilder reference!

    • Good call! Done!

  4. There’s no repetition in:
    int lastCharIndex = toReverse.Lenght – 1
    as opposed to:
    Dictionary<int, Dictionary> lookup = new Dictionary<int, Dictionary>();

    I’d rather use var in the 2nd case where initialization and declaration match. In the 1st case, the type might not always be evident without using the mouse – like in this example:
    var table = GetBindingsTable();

    And a second concern about the loose coupling: are you not afraid that one day you’ll get the wrong type because somebody else change a method and the compiler will not warn you just because it happens to have the same public API? I’m afraid that this could introduce subtle bugs…

    • Good point, I still wonder in the first case do you actually need to know the type? You really just need to know the methods available on the type. Think about how we use interfaces. The same would apply about someone changing the type.

  5. Ok, wild…. even the code definition window will work with the var keyword… bizzzzzarre!

    I typically like to click the variable, hit F12, then click the type, and hit Ctl+\+d (control backslash d) to show the type def (frequently from metadata) in the Code Definition Window… or just F12 again.

    But I was shocked when I changed Uri to var, hit Ctl+Sh+b (compile) and then hovered over the var … hit Ctl+\+d and there was Uri (from metadata) in the Code Definition Window… what a shocker.

    I’m so confused! this seems just wrong from a best-practice standpoint, but totally Rock-N-Roll from the standpoint of how crappy JavaScript is regarding F12. It almost reels C# into VB territory… perhaps we’ll see something interesting now for C# like in VB now with COM interop…. perhaps I’m missing it and this IS it.

    Dan “Stoic Strong Type’r” Wygant

  6. For me your caveat says it all. The need for the ide to be able to supply you with the type information is a clear indicator that you need to know the type information. I feel that if you cannot read/write the code without the ide you did something wrong. Don’t get me wrong, I love the ide, I love the productivity gain, but I also love being able to use my skills even with inferior tooling. Personally I’m in agreement with Dejan, using var when the initialization clearly shows you what type your using is fine, but using var for every declaration does in my opinion makes your code harder to read because you have to backtrack to discover what types are in play.

  7. “Perhaps I just like to repeat myself = new Perhaps I just like to repeat myself.”

    Actually made me laugh out loud! thankfully no one is around. Great post!

  8. […] consider var to actually be quite a useful language feature to reduce repetition and make your code slightly more flexible for refactoring, but I’ve always […]

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s


%d bloggers like this: