Let’s Talk C# Features, Pt 3

Posted in .NET, C#, XNA on May 13, 2008 at 12:34am.
There are 3 comments.

This will be my last post tonight and coincidentally the last feature of C# 3.0 that will work for all platforms. This compiler trick is the new “implicitly typed local variable”. What does that mean? It means that, for local variables, you no longer have to type the variable type if you also instantiate or initialize it on that same line. The compiler will infer the type from the rest of the line and fill in the type for you. This new feature is done through the ‘var’ keyword. So for instance where you used to write something like this:

string a = "Hello World";

You can now write it like this:

var a = "Hello World";

Before I continue let me clear two things up that some of you might not get right now. First of all this is only for local variables. This means variables that exist only in the scope of a single method. Class level variables, properties, parameters, and method return values cannot be implicitly typed. Secondly this is not weak typing of variables. This is simply a compiler trick so you type less. With the above line the compiler and Intellisense both know of which type is ‘a’. So when you type a followed by a period, you’ll see the same Intellisense help you’ve always seen for a string type. No weak typing; just less typing.

So now you are wondering, “Gee, Nick, this is great and all, but that’s not saving me that much work.” Well we haven’t gotten to the fun stuff yet. Let’s say you have a class called Client and a class called FinanceReport. Let’s now say you want to make a local dictionary using Client for the key and a list of FinanceReports for the value. This is normally what you would see for that declaration:

Dictionary<Client, List<FinanceReports>> clientFinanceReports =
       new Dictionary<Client, List<FinanceReports>>();

That looks like an awful long line for something as simple as that. With implicit typing, though, we can reduce the line by a large amount:

var clientFinanceReports =
       new Dictionary<Client, List<FinanceReports>>();

Way shorter now. And you can also use var for things like for and foreach loops to make things easier. Let’s say we have that above dictionary and we want to iterate over all the key-value pairs. Previously this is what our loop would look like:

foreach (KeyValuePair<Client, List<FinanceReports>> keyValuePair
                in clientFinanceReports)
{
    //do something useful
}

And now with implicit typing:

foreach (var keyValuePair in clientFinanceReports)
{
    //do something useful
}

How nice is that? You no longer have to write all that generics stuff to loop over the collection saving you lots of typing time.

So remember, everything I’ve shown so far (implicit typing, collection initializers, object initializers, and auto-implemented properties) are all compiler tricks meaning that these will work already on the Zune and Xbox 360 in addition to Windows. The rest of the features I’ll be showing in the next couple days will not work on Zune or Xbox 360 because they do require some runtime enhancements to function properly.

Post A Comment