Facilitating the Spread of Knowledge and Innovation in Professional Software Development

Write for InfoQ


Choose your language

InfoQ Homepage News C# Debate: When Should You Use var?

C# Debate: When Should You Use var?

This item in japanese

Lire ce contenu en français


C# 3 added the keyword "var". This allows for local type inference when the compiler can unequivocally determine what type the variable should be. There is, however, some debate as to when it should be used.

Ilya Ryzhenkov from the IDE tool company JetBrains outlines some benefits for using var,

  1. It induces better naming for local variables.
  2. It induces better API.
  3. It induces variable initialization.
  4. It removes code noise
  5. It doesn't require the using directive.

Dare Obasanjo of RSS Bandit does not agree. He wrote a response to Ryzhenkov's position after seeing what he thought of as detrimental changes to his open source project. He counters with,

It's interesting how not only are almost all of these "benefits" mainly stylistic but how they contradict each other. For example, the claim that it leads to "better naming for local variables" really means it compels developers to use LONGER HUNGARIAN STYLE VARIABLE NAMES. Funny enough, these long variable names add more noise to the code overall since they show up everywhere the variable is used compared to a single type name showing up when the variable is declared. The argument that it leads to "better API" is another variation of this theme since it argues that if you are compelled to use LONGER MORE DESCRIPTIVE PROPERTY NAMES (e.g. XmlNode.XmlNodeName instead of XmlNode.Name) then this is an improvement. Someone should inform the ReSharper folks that encoding type information in variable names sucks, that's why we're using a strongly typed programming language like C# in the first place.

One more thing, the claim that it encourages variable initialization is weird given that the C# compiler already enforces that. More importantly, the common scenario of initializing a variable to null before it is used isn't supported by the var keyword.

Dare backs up his claim with this line from the official 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.

The complaint that var reduces readability is not shared by everyone. Arnon Rotem-Gal-Oz writes,

As for the code readability claim, I prefer to focus on stronger methods like keeping methods short, meaningful method and variable names and supporting tests (which can actually help you understand how the code behaves...). Not to mention that, if you really really need that, resharper will tell you the type if you put the mouse over the var keyword ;)

Chris Sutton seems to go further and implies that the type really doesn't matter.

Then the suggestion came up that you should only use var when you don’t know the type. Here is where I differ in opinion and usage. Look at the following snippet

var procs = from p in ServiceController.GetServices()
where p.Status == ServiceControllerStatus.Running
select p;
procs.ToList().ForEach(p=> Console.WriteLine(p.ServiceName));

procs is certainly IEnumerable but it doesn’t matter to me. I primarily care that procs is a list and that the individual items in the list have a Property called ServiceName. The underlying type is important to the compiler, but the people that have to read code aren’t compilers right?

Rate this Article


Hello stranger!

You need to Register an InfoQ account or or login to post comments. But there's so much more behind being registered.

Get the most out of the InfoQ experience.

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Community comments

  • I would say use var wherever you can use it

    by Sadek Drobi,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    var has a lot of benefits. It forces initializing to not null value, and it introduces flexibility inside the method scope as Chris illustrated in his example.

  • You use var when no one cares about the type.

    by Francois Ward,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    Often, the initialization is the only part that matters in a variable.

    - In LINQ queries

    - IN FOREACH LOOPS:foreach( var blah in someCollection), that one is big
    -Dictionnaries. The difference between a dictionnary that cares about case or doesn't depends on the comparer. People who look just at the type will miss that. Using var in that case force people to look at the initialization.
    -When using datasets/dataadapter, especially typed ones... the declaration gets rediculous and is just noise.

    There's more. You shouldn't use var everywhere, that reduces the information the code gives to a reader just by looking at it (without mouse overs). But the above scenarios clearly benifit from it. When you don't know the type and only the initialization matters (like foreach and linq), or when declaration just adds visual noise.

    Don't go using var blah = 12; that just takes away from the intention. Is that an int? A float? I know its an int, but I don't know if it was your intention...

  • Re: I would say use var wherever you can use it

    by Jonathan Allen,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    I don't know about that. I suspect most people would decide whether or not they are initializing to null first, then use var accordingly.

  • Re: I would say use var wherever you can use it

    by Sadek Drobi,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    Usually I don't like initializing to null, but sometimes I find myself forced to because of some language limitations. So I can agree with you.

  • When to use type inference

    by Shirvan Noormohammadifar,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    OK, there is always tradeoffs, Everywhere we want to use something in code we must have reasons for it, there aren't necessary reasons to push me for using type inference everywhere in my code, and here are drawbacks:

    yes of course, var is type safe but what is our gain in using it everywhere?

    compiler acts like this: when sees the var keyword it tries to find the type of variable based on the value assigned to it, this means that we can't assign a value that compiler can't determine it's type, and this results to:

    We can't use var when initializing a variable to null, cause compiler can't determine it's type.

    OK lets see another case, suppose we have the following line of code:

    var amount = 13;

    Now what is amount? int16, int32 or int64?

    or another example:

    var tax = taxCalculator.GetTax(amount);

    Now what is the type of tax???

    These are really confusing and it's not a good practice to use type inference in these situations.

    Or something like this:

    var firstName = "shirvan";

    What is our gain using var instead of string??? i think nothing.

    In DRY case I'm agree that repeating is unnecessary in variable declaration and in my opinion the right side type declaration is unnecessary and redundant, but to get rid of this redundancy c# compiler should take the responsibility and enables this feature(maybe in future releases) instead of using var and sacrificing readability.

    The var keyword is very cool feature in c# 3.0, I'm also a big fan of Intelligent laziness and less typing but i think it's not applicable here and we shouldn't use type inference everywhere in our code, the right place to use it is when dealing with anonymous types or a collection of anonymous types.

    Shirvan Noormohamadifar

  • Re: When to use type inference

    by Jeff Harris,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    Excluding arguments about the variable names, what about :

    NotificationClient client = new NotificationClient();
    NotificationRequest noteReq = new NotificationRequest();
    NotificationResponse noteResp = new NotificationResponse();

    1. That's redundant as heck and adds noise.
    2. It's not as visually aligned and tidy looking as this is:

    var client = new NotificationClient();
    var noteReq = new NotificationRequest();
    var noteResp = new NotificationResponse();

  • Re: When to use type inference

    by Ricardo Serradas,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    That's the answer! Here I agree completely.

    I think we should use var moderately. It's like alcohol here in Brazil: "Aprecie com moderação" ("Enjoy it moderately").

    In cases of variable initialization, it's great. Assigning a value which has an explicit type (like int or string) is good either.

    But use it in a variable which receives a response from a method is not good at all, like:

    var x = DoSomethingAndReturnSomethingElse("SomeValue");

    Well... Like almost everything: enjoy it moderately!

    Ricardo Serradas
    Visual Studio ALM in a nutshell -

  • But, that has always been my point...

    by Jason Hill,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    "I primarily care that procs is a list and that the individual items in the list have a Property called ServiceName"

    Precisely! And isn't it a lot simpler and straight forward to know that the object has a particular property or implements and particular interface if you actually know what type the object is?!?

    I honestly don't get the argument, "I don't care what it is, I just need to know what it does and how it works." To me, the need to know how it works and functions is greatly enhanced by knowing what it is.

    Yes, I am NOT a fan of var. But I am not a fan of scripting or non-typed languages. To me, they suck. I spend more flipping time in Javascript trying to find out if value is a string or an int, that if I just knew that up front I could make all the programming decisions I need to make.

    I have never, ever, ever once said, "Wow...these variable names are just too long and it makes too much 'noise' having all this information up front..." I just do not get it. At all. As a programmer, I instantly and immediately want to know what I have in front of me so that I can know how to utilize it. Spending the first 1/3 of my time analyzing what type ends up in var when I could be designing and developing just drives me batty.

    To me, it is only easier for the original coder. Since the lion's majority of any code cost is in maintenance, this is a false savings. You are driving up maintenance cost in dollars saving a few pennies in reducing 'noise' or 'typing'. My own two cents anyway.

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p