I've been reading lately about what people are interested in with the next version of C#. It's amazing to think how far the language has come from the early days. Many of the newer features of the language with 3.0 by far have made it a better language.
So, what did we get with the latest C# 3.0?
- Object Initializers
- Automatic Properties
- Anonymous Types
- Extension Methods
- Lambda Expressions
- LINQ
- Collection Initializers
By far, I agree with most of sentiments regarding C# vNext, including:
- Mixins
- Ruby-like Symbols
- Hash language features
- Automatic Delegation
I'll throw Spec# features and Duck Typing onto the pile. As you may note from my earlier posts, parts already exist in.NET 3.5 libraries, so it's not hard to imagine that might open up a bit. Plus, since I've given several presentations on the matter, I'm pretty into it. But, also some of F#'s features are great as well that I'd like to see more merging includes mutables. A good introduction to F# can be found. But, then again, why not just stick to F#?
What might in store for C# 4.0 anyhow? Well, if you follow Eric Lippert, one of Microsoft's best bloggers, like I do, there are some things that are very interesting that he's been working on including ) with his ten post series:
Each of these are worth a read:
- Part One
- Part Two: Array Covariance
- Part Three: Method Group Conversion Variance
- Part Four: Real Delegate Variance
- Part Five: Higher Order Functions Hurt My Brain
- Part Six: Interface Variance
- Part Seven: Why Do We Need A Syntax At All?
- Part Eight: Syntax Options
- Part Nine: Breaking Changes
- Part Ten: Dealing With Ambiguity
Also, could immutability be another thing coming? If you're a follower of Domain Driven Design, you like Value Objects and Immutability. Spec# also introduces this concept to C# as well through the use of attributes. And since parts of Spec# covers this, it's also very likely. Anyhow, Eric Lippert also covers this in a "hypothetical way":
- Part One: Kinds of Immutability
- Part Two: A Simple Immutable Stack
- Part Three: A Covariant Immutable Stack
- Part Four: An Immutable Queue
- Part Six: A Simple Binary Tree
- Part Seven: More on Binary Trees
But, with all new features, there are diminishing returns as noted by. I'd have to agree with this point. At some point, what are these new features going to give you when other languages can do these things more naturally? If, say C# doesn't have a certain feature, but IronRuby does, why not use IronRuby? Also, keeping on piling on features will ultimately make the language more complex and sifting through the various answers to find the right one becomes a bit harder.
I disagree with others like Jeremy that call for an end and stick a fork in C#. It's not done yet and I think it holds much more promise before we call it a day.
