{"id":1039,"date":"2010-07-04T17:27:02","date_gmt":"2010-07-04T11:27:02","guid":{"rendered":"http:\/\/aasims.wordpress.com\/?p=1039"},"modified":"2025-04-07T20:31:32","modified_gmt":"2025-04-07T20:31:32","slug":"get-ready-for-c-4-0","status":"publish","type":"post","link":"https:\/\/aasimnaseem.com\/blog\/get-ready-for-c-4-0\/","title":{"rendered":"New Features in C# 4.0"},"content":{"rendered":"

\"\"Visual Studio 2010 is packed with new and enhanced features that simplify the entire development process from design to deployment. Customize your workspace with multiple monitor support. Create rich applications for SharePoint and the Web. Target multiple versions of the .NET Framework with the same tool. Eliminate the dreaded “no repro” problem with IntelliTrace. And much more.<\/p>\n

Visual Studio 2010 is here!<\/a>And of course this means that C# 4.0 is also here. Let\u2019s do a quick review of the new language features added in this release.<\/p>\n

\n
\n
\n
\n
\n
\n

Dynamic<\/h4>\n

The\u00a0dynamic<\/strong> 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\u00a0System.Dynamic<\/a>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:<\/p>\n

dynamic\u00a0contact =\u00a0new\u00a0ExpandoObject();<\/p>\n

contact.Name =\u00a0“Patrick Hines”;<\/p>\n

contact.Phone =\u00a0“206-555-0144”;<\/p><\/blockquote>\n

Covariance and Contravariance<\/h4>\n

Variance on generic type parameters in interfaces and delegates is another important feature of this release. It doesn\u2019t 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\u2019t compile until C# 4.0:<\/p>\n

\n
\n
IEnumerable<Object> objects =\u00a0new\u00a0List<String>();<\/div>\n<\/blockquote>\n<\/div>\n
The ability to implicitly convert references for objects instantiated with different type arguments makes it much easier to reuse code. Read the\u00a0Covariance and Contravariance FAQ<\/a> to learn more about this feature.<\/div>\n
\n

Optional (or Default) Parameters<\/h4>\n

People have been asking for this feature since C# 1.0. Three versions later, it\u2019s finally here.<\/p>\n

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.<\/p>\n

Method declaration:<\/p>\n

public\u00a0static\u00a0void\u00a0SomeMethod(int\u00a0optional = 0) { }<\/p><\/blockquote>\n

\n
Method calls:<\/div>\n
\n
SomeMethod();\u00a0\/\/ 0 is used in the method.<\/p>\n

SomeMethod(10);<\/p>\n<\/div>\n<\/blockquote>\n

\n

Named Arguments<\/h4>\n

The order of parameters in a method declaration and the order of arguments you pass when calling the method don\u2019t 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.<\/p>\n

var\u00a0sample =\u00a0new\u00a0List<String>();<\/p>\n

sample.InsertRange(collection:\u00a0new\u00a0List<String>(), index: 0);<\/p>\n

sample.InsertRange(index: 0, collection:\u00a0new\u00a0List<String>());<\/p><\/blockquote>\n

Read more about optional parameters and named arguments on\u00a0MSDN<\/a>.<\/p>\n<\/div>\n

Improved COM Interop<\/strong><\/div>\n<\/div>\n

The introduction of the\u00a0dynamic<\/strong> keyword, optional parameters and named arguments enables improvement of COM interop. So, no more ugly code like this:<\/p>\n

var\u00a0excelApp =\u00a0new\u00a0Excel.Application();<\/p>\n

\/\/ . . .<\/p>\n

excelApp.get_Range(“A1”,\u00a0“B4”).AutoFormat(<\/p>\n

Excel.XlRangeAutoFormat.xlRangeAutoFormatTable3,<\/p>\n

Type.Missing,\u00a0Type.Missing,\u00a0Type.Missing,<\/p>\n

Type.Missing,\u00a0Type.Missing,\u00a0Type.Missing);<\/p><\/blockquote>\n

You can now simply write the following:<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

excelApp.Range[“A1”,\u00a0“B3”].AutoFormat(<\/p>\n

Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic2);<\/p><\/blockquote>\n

By the way, this code uses one more new feature:\u00a0indexed properties<\/a> (take a closer look at those square brackets after\u00a0Range<\/strong>.) 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\u00a0MSDN<\/a>.<\/p>\n

What Else?<\/h4>\n

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.<\/p>\n

Here are some links for further reading:<\/p>\n