« C# 3.0 Auto-Implemented Properties
C# 3.0 Object and Collection Initialisers »

C# 3.0 Implicitly Typed Local Variables

Implicitly Typed Local Variables are strongly typed variables that you define used the keyword var instead of the name of your type:

var i = 5;

The type is then inferred for you by the compiler by looking at the type of data that you populate the variable with.

WARNING.  I have already had the situation where developers think that this feature is here to prevent them from using the conventional manner of instantiation anywhere in their programs.  IT IS NOT!  Whilst vars have their uses, you should not have to hover your mouse over a variable to know its type, no matter how “pretty” you think that your code looks! If you do not need to use a var then don’t use a var.

Implicitly Typed Local Variables have been introduced (IMHO) to enable anonymous types and to ease the use of LINQ.  They can be used with the following types:

  1. Built-in types.
  2. Anonymous types.
  3. User-defined types.
  4. Any type defined in the .NET Framework class library.

They can be used in the following situations:

  1. With local variables.  Var cannot be used for instance or class variables.
  2. In a foreach statement.
  3. In a using statement.

The examples listed below show the compilation-valid uses separated into what I would consider to be good and bad uses (the clue is in the method names):

private void GoodUses()
{
// expr is compiled as IEnumerable<Customer>
// or perhaps IQueryable<Customer>
var expr = from c in GetCustomers() where c.City == “London”
select c;// The type returned could be complex and hard to track down
foreach (var customer in GetGroupedCustomers())
{
if (customer.City == “London”) break;
}
}

public void PoorUses()
{
var i = 5; // i is compiled as an int
var s = “Hello”; // s is compiled as a string
var a = new[] { 0, 1, 2 }; // a is compiled as int[]
var list = new List<int>(); // list is compiled as List<int>
}

private void OnlyWayToDoIt()
{
// anon is compiled as an anonymous type
var anon = new { Name = “Terry”, Age = 34 };
}

You cannot use Implicitly Typed Local Variables in the following cases:

  1. As an instance or class variable.
  2. As a return parameter in a method.
  3. As an input parameter to a method (unless used as input to a Lambda expression).
  4. When the variable is not declared and initialised in the same statement.
  5. When the variable is used in its own initialisation (although I’m not sure I’d be happy with any of my developers doing this anyway).
  6. In multiple defined variables in the same statement.
var GetAsVar() { return 1; }  // Cannot be a return parameter
void SetAsVar(var v) { int i = v; } // Cannot be an input parameter
private var _notAllowed; // Cannot be an instance variable
private static var _alsoNotAllowed; // Cannot be a class variableprivate void NotAllowed()
{
var foo;        // Must be initialised
foo = “Hello”;

var i = (i = 20); // Cannot be used in an initialisation statement
var a, b, c = “Multiple”;
}

A little GOTCHA is that if you’ve decided to name one of your types var for some reason then firstly shame on you and secondly, any attempt to use the keyword var will then result in the compiler attemtping to declare a variable of your type and NOT of an Implicitly Typed Local Variable.

More details can be found here.

Note that a lot of the code samples have come from Microsoft and as such I am obviously NOT taking credit for them.

To read about more C# 3.0 enhancements click here.

Tags: ,

This entry was posted on Monday, March 2nd, 2009 at 21:39 and is filed under C#. 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.

2 Responses to “C# 3.0 Implicitly Typed Local Variables”

  1. Matt says:
    7 March, 2009 at 04:47

    I’d hazard a guess that even:

    int i = (i + 20);

    won’t compile due to it being unassigned when you are trying to use it!

    Matt :)

  2. Andrew Murphy says:
    11 March, 2009 at 18:51

    Try it. It does! Or rather “int i = (i = 20)” does, which is what I meant to type :-). I didn’t believe it though and it would never pass a code review but there you are, for some reason it does.

    The example is lifted directly from the Microsoft documentation here, under remarks.

Leave a Reply

You must be logged in to post a comment.