Saturday 29 August 2009

.NET 4.0 CLR Enhancements

I was looking at .NET 4.0 and was thinking if there are any enhancements to the CLR at least this time? (Remember the last enhancement of the CLR was about 4 years back with the release of .NET 2.0. Both .NET 3.0 & 3.5 used the CLR which comes with .NET 2.0). As it turns out, the CLR part of .NET 4.0 has quite a lot of enhancements. So without further ado, lets look at the enhancements…

  • In-process side By Side CLR

I guess this is one of biggest enhancement in the CLR. In the earlier versions, the host process can only load one version of the CLR. CLR used something known as the unification policy to figure out the single version of the CLR to be loaded in the process. This can cause compatibility issues to say the least. The biggest challenge with this limitation is for the add-in developers as they can’t be sure which version of .NET framework their code will be run. The code has to be checked for various compatibility issues if the authors need it to be perfect.

With .NET 4.0, it will be possible to run multiple CLR versions side by side on the same process. So it is possible to have a host process which has three add-ins developed in .NET 1.1, .NET 2.0 and .NET 4.0. This should be music to the ears of add-in developers.

  • GC enhancement

Pre .NET 4.0, when Garbage collection happens you would notice the application to pause when the Gen 2 size is quite large. Also, the GC is a concurrent GC i.e. it will not be able to do Gen 2 collection when Gen 0/Gen 1 collection is in progress and vice versa.

With .NET 4.0, collection algorithm has undergone quite a bit of change which means the collection will be faster than before. However, the application will still pause when collection happens. .NET 4.0 provides notification feature which can be used to get notified before collection happens.

.NET 4.0 also provides a new type of collection named Background collection. With background collection, Gen 0/Gen 1 collection can happen while doing Gen 2 and vice versa. This will help in reducing the latency during application execution.

  • Support for Dynamic & Functional Languages

With .NET 4.0, there will be support for dynamic and functional languages like IronPython, IronRuby, F#, etc. With the support for these languages, CLR will have capabilities like Tuples, Biginteger and Tail Recursion which were added for these languages. All the languages supported by the .NET framework will be able to benefit from these additions for example, biginteger can be used in C#.

  • Corrupted State Exceptions

There are certain exceptions which cannot be caught by normal catch statements like Invalid Memory, AccessViolation, etc. It is possible to catch these exceptions with .NET 4.0 with the help of Corrupted state exceptions. Corrupted state exception(CSE) can be handled by the program by adding the attribute [HandleProcessCorruptedStateExceptions] which signals to the CLR that the program wants to handled CSE.

  • Code Contracts

Code contracts introduced in .NET 4.0 is a best way to tell the compiler about what we know about our program in terms of parameters and their permissible values for a particular function. Code contracts helps you to provide the behavior of the function in terms of pre-conditions and post-conditions. These conditions helps to perform both runtime and static analysis of the code behavior.

  • Native/Managed Interop

With .NET 4.0, there wont be any PIA’s which makes it easier for the managed application to call COM libraries. The TLBIMP tool will be available as a shared source through codeplex thus making it easy to modify the code based on our requirements to generate the interop assembly.

P/Invoke has become much simpler with .NET 4.0 with the use of wrapper tool. With the wrapper tool it will be easy to create P/Invoke wrappers for windows API’s.

  • Threading for multi core

Parallel extensions in .NET 4.0 help to write programs which target the multi-core environment. Parallel extensions make use of the Thread pool part of the CLR for allocation of threads. Thread pool has been enhanced to provide better support for multi-core scenarios.

  • Profiling

Its not longer required that you have Visual Studio installed on your production servers to do profiling of the application. With .NET 4.0, new API’s have been added which enables to attach/detach performance and memory profilers.

  • Debugging

With .NET 4.0 it is now possible to do dump debugging using the interface ICorDebug.

Phew!!! that’s quite a lot of enhancements to the CLR. Of the whole lot, my favorites are the In-process side by side CLR, GC enhancements and Code contracts.

Reference: CLR Futures by Joshua Goodman

Technorati Tags: ,

2 comments: