Get Ready For C# 4.0!

Get Ready For C# 4.0!

Rate This
  • Comments 70

Visual Studio 2010 is here! And of course this means that C# 4.0 is also here. Let’s do a quick review of the new language features added in this release.

Dynamic

The dynamic keyword is a key feature of this release. It closes the gap between dynamic and statically-typed languages. Now you can create dynamic objects and let their types be determined at run time. With the addition of the System.Dynamic namespace, you can create expandable objects and advanced class wrappers, and you can provide interoperability between different languages, including dynamic ones. Here is one quick example:

dynamic contact = new ExpandoObject();
contact.Name = "Patrick Hines";
contact.Phone = "206-555-0144";

I have discussed the pros and cons of this feature on this blog. If you want to know more, read here.

Covariance and Contravariance

Variance on generic type parameters in interfaces and delegates is another important feature of this release. It doesn’t add much new functionality, but rather makes things work as you expected them to in the first place. The major advantage is hidden in this simple line, which didn’t compile until C# 4.0:

IEnumerable<Object> objects = new List<String>();

The ability to implicitly convert references for objects instantiated with different type arguments makes it much easier to reuse code. Read the Covariance and Contravariance FAQ to learn more about this feature.

Optional (or Default) Parameters

Looking at the archives of this blog, I see that people have been asking for this feature since C# 1.0. Three versions later, it’s finally here.

Now you can assign a default value to a parameter right within the method declaration. The user of the method can either pass a value or simply skip the argument. In the latter case, the default value is passed to the method.

Method declaration:

public static void SomeMethod(int optional = 0) { }

Method calls:

SomeMethod(); // 0 is used in the method.
SomeMethod(10);

Named Arguments

The order of parameters in a method declaration and the order of arguments you pass when calling the method don’t need to match anymore. You can provide arguments in any order you like by specifying parameter names in a method call. This might also improve the readability of your code.

var sample = new List<String>();
sample.InsertRange(collection: new List<String>(), index: 0);
sample.InsertRange(index: 0, collection: new List<String>());

Read more about optional parameters and named arguments on MSDN.

Improved COM Interop

The introduction of the dynamic keyword, optional parameters and named arguments enables improvement of COM interop. So, no more ugly code like this:

var excelApp = new Excel.Application();
// . . .
excelApp.get_Range("A1", "B4").AutoFormat(
    Excel.XlRangeAutoFormat.xlRangeAutoFormatTable3,
    Type.Missing, Type.Missing, Type.Missing,
    Type.Missing, Type.Missing, Type.Missing);

You can now simply write the following:

excelApp.Range["A1", "B3"].AutoFormat(
    Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);

By the way, this code uses one more new feature: indexed properties (take a closer look at those square brackets after Range.) But this feature is available only for COM interop; you cannot create your own indexed properties in C# 4.0.

For more information about new COM interop features, once again, refer to MSDN.

What Else?

Of course, C# benefits not only from new language features, but also from improvements to its integrated development environment (IDE) and to the .NET Framework.

Here are some links for further reading:

Happy coding, and thanks to all of you who helped to make this release better by providing feedback!

Leave a Comment
  • Please add 1 and 2 and type the answer here:
  • Post
  • @ Alexandra Rusina

    Thank you for your quick reply ^_^.  I just wanted to make sure that these features didn't have some issues that I wasn't aware of.

    In C#, how would I declare an optional paramter of struct or a dynamically allocated array?

  • C# is getting beter but as all professional can get is that all microsoft will get all benefits from all programming languages to get final & Powerfull C# language.

    Eidivandi@live.com    

    MCPD -  

  • i m looking for benefits of WPF but what i have catched is so that this is not enough for begin a large project ,

    and 1 question for my test example is that i cant move the label control in the canvas layout control

    plz help me ,

  • @ Tamino

    Here is what I've got from C# team:

    "Optional parameter of a struct type S is allowed. The only default argument you can specify is default(S).

    You cannot specify dynamically allocated arrays. (they cannot be represented in metadata). You can of course specify null as the default argument for an array, and then allocate an array in the method body when that argument is null. But you cannot know if the null was explicitly passed in the call, or results from an omitted argument."

    So, the answer is yes, they are allowed, but not very useful in these scenarios.

    @ Eidivandi

    I'd recommend to ask such questions at MSDN forums. Here is the one for WPF:

    http://social.msdn.microsoft.com/forums/en-US/wpf/threads/

  • @ Alexandra

    Thank you for the response ^_^.

    Being unrepresentable in metadata doesn't sound encouraging for future support.  Is this the reason why no .NET version of either Fortran 9X or Fortran 2003 is on the horizon?  But at least the basic datatypes can be optional now so this is still a step forward.

  • I agree with @CSharpner.

    Personally, I think one of the cool features of C# as opposed to other languages is its structured approach to programming and therefore i dont like the dynamic keyword.

    Having also used c++, I have to say that I do not like the optional parameters addition either.

  • The dynamic keyword kan be very handy. I agree that it may cause lots of bad stuff, but those that abuse the dynamic keyword shouldn't be coding in the first place at all as only crappy coders would abuse it.

  • Hello.

    Probably, I am missing something very very fundamental here, but I was shocked to see the following statement in your post:

    "By the way, this code uses one more new feature: indexed properties (take a closer look at those square brackets after Range.) But this feature is available only for COM interop; you cannot create your own indexed properties in C# 4.0."

    I tried compiling a small class having indexers with the C# 4 compiler that was shipped with VS 2010 beta and I could use the indexers just as I can with the earlier versions of C#. Then, what's changed?

    Kindly clarify my confusion. Thank you!

  • I want to know how to use operators like +, -, / or * with Generic Classes in C# 4.0

  • Isn't it about time Microsoft provided a decent .NET wrapper for Excel (and the rest of Office) so we don't need to guddle about in COM interop at all?

  • @ Tamino

    As far as I know, Fortran is not a Microsoft language. I can't say anything about it.

    @Pankaj Sharma

    These are two different features: indexers and indexed properties. You can always have myObject[0]; but here is a different scenario - myObject.MyProperty[0]; This is supported for COM interop only.

    @Bobby

    Sorry, but I am not sure I understand your question. Can you please provide a code example of what you are trying to do?

    @Robert

    This is probably what you should file at Microsoft.Connect: https://connect.microsoft.com/VisualStudio?wa=wsignin1.0

  • Starting to look more and more like c++.

    Why not just skip c# and use c++ instead

  • Any chance we'll be getting some way of having numeric types as a constraint on generics?

    e.g:

    public class Foo<T> where T:Numeric{}

    so that we can make, say functions that expect T to contain math operators? (I think this is sort of what Bobby was asking)

    Would also be nice to be able to say what types are NOT desired in constraints :D

  • I have to agree with Csharpner to a large degree.

    Optional parameters makes code difficult to read and maintian if you were not the one to write it originally.  If you have a large number of parameters for a method, you probably have a method that is doing to much and really should be refactored into several smaller methods.  This is a bad code smell.  I understand that COM interop has many instances of this showing up especially when working with Excel.  I still would have to recommend against using this with your own code that is not COM.

    As far as dynamic goes and variant for that matter, this is useful in a limited circumstance as well.  If you are writing code that does not rely on interoperating with dynamically typed languages, you should avoid using this feature.  C# was designed to be a strongly typed language cousin of VB NOT to be VB written a little differently.  Good programming practice should be to know what types are going in and out and around your program.  There is a great opportunity for dynamic to be misused/abused so you don't have to think about what you are doing.  Bad practice.

    I understand that both of these additions have their place, but I also believe that their place is very narrow and should be kept that way.

    Shortcuts to get a job done quickly rarely lead to maintainable code or easily debugged code.  Proper forethought and design are essentia to professional, maintainable code.

    Dumbing down C# is likely to lose support of many highly trained professional developers as we will not want to have to fix the broken mess created by shortcut programmers.

  • Some of these features seem pretty neat.  But I wonder if there will be new controls in the GUI toolbox for Visual Studio.

Page 4 of 5 (70 items) 12345