I’m trying to improve the content of the blog, so I added 3 new and so far quite incomplete sections:
It’s also a way of organizing the content in a better way and saving links to the stuff I like without cluttering the blog (I hate posts that just link to other’s people work or content). I hope it can be useful for some of you out there. See you next time!
I finally watched the talk about the future of C# that Anders Hejlsberg presented at the last PDC. I had previously read a short paper about the new features in C#4 and a couple of posts by Eric Lippert (look for the five parts series called “The Future of C#”), so I knew about most what he was talking about, but he helped me to understand the whys and to put everything in perspective.
Each C# version’s feature set has been centered on a theme, which helps to prioritize the proposals and to focus the development efforts. So far we’ve had:
Of course, in practice there are always features that don’t fit well within the major theme of a version (for example anonymous methods have nothing to do with generics, partial methods had nothing to do with LINQ, and so on). I suggest you to read this post by Eric Lippert to see his slightly different point of view about this topic. For C# 4.0 the theme is dynamic programming (according to Anders, for Lippert it looks more like a “grab-bag”), but what does this mean in terms of features? Here they are:
According to Lippert, this may seem like a small set of features, and I agree, but he says it was deliberate:
Some feedback that we received loud and clear through the C# 3.0 ship cycle was “this is awesome, we need these language features immediately!” and, somewhat contradictorily, “please stop fundamentally changing the way I think about programming every couple years!” Rather than trying to find some way to yet again radically increase the expressiveness and power of the language, we decided to spend a cycle on making what we already have work better with the other stuff in our programming platform infrastructure.
Let me review each feature in more detail.
Dynamically typed objects
C# 4.0 will allow you “to write method, operator and indexer calls, property and field accesses, and even object invocations which bypass the C# static type checking and instead gets resolved at runtime”. This was implemented by introducing a new type called “dynamic“, which under the hoods is just an object type marked with the new Dynamic attribute, so basically we have objects that are statically typed to be dynamic (!). In my opinion this is a clever idea because it flows nicely through the type system, and works well with things like refactoring.
In practice, this means that code that currently looks like this in C# 3.0 (assume the GetCalculator method returns an object whose type is not known at compile time):
Could look like this in C# 4.0:
Here the variable calc is statically typed to be dynamic, the invocation of the Add method is dynamic and there’s also a dynamic conversion of the result to an integer. This is more or less what you can do in Visual Basic when you turn off the strict option, the key difference being the new dynamic type. When the operands are dynamic:
I bet this is going to be a controversial feature for many people because after all C# is supposed to be a strongly typed language. Anders himself acknowledged this after presenting the feature: “So now you may go, well, gosh Anders have you gone start driving mad? Haven’t you told us for ten years that static typing is the right and only way, and now you are being heretical?”. I admit I didn’t like it at all at first, but after thinking about it I decided I prefer to maintain 10 lines of dynamic code than 100 lines of reflection based code. If it’s not type-safe then at least I want it to be readable.
If you want to know all the details about this feature I strongly recommend you to read these excellent (and long) series of posts:
Optional and named parameters
A parameter is declared optional by providing a default value for it:
public void MyMethod(int x, int y = 5, int z = 7);
In C# 4.0 you can pass any of those parameters by name, and you can also omit y and z:
MyMethod(1, 2); // omitting z – equivalent to MyMethod(1, 2, 7)
MyMethod(1); // omitting both y and z – equivalent to MyMethod(1, 5, 7)
MyMethod(1, z: 3); // passing z by name
MyMethod(x: 1, z: 3); // passing both x and z by name
I see two big benefits derived from these features (beside the COM thing I mention later):
Check out this nice post by Sam NG for more details about this feature.
Improved COM interoperability
I don’t care about this too much since I’ve never had to interop with COM that much. The improvements are the following:
As you can see, the most important improvements are due to the other new features in the language.
Co-variance and contra-variance
Finally we’ll have some variance support in .NET! I’ve wanted this for a long time so I was quite glad when I heard it would be implemented, but there are a few limitations though. Here are some things to keep in mind:
So how does it work?
(Does the “statically checked definition-site variance” thing make more sense now?)
I think the value of this feature can be captured in a phrase that Anders said during the talk: “You’ll be able to do things that you were surprised you couldn’t do”.
C# and VB
Another important announcement made in the talk was that C# and VB will co-evolve from now on, meaning that the same features will be introduced to both of them at the same time (when it makes sense of course). “Co-evolution is the right way to evolve these languages” said Anders, and I think this is totally true. Well, I like the idea of having the VB team copying the features that the C# team introduces, but I’m not so sure if I like it the other way around :)
Highlights of the presentation
Here are a few interesting things that Anders mentioned:
OK, that was a long post (I hope it wasn’t too boring). I really suggest you to go watch the presentation and get the CTP. See you next time!