Microsoft has recently launched Visual Studio 2010 and .Net 4.0 Beta 1 with more expressive features. Some of them are mentioned below:

[New Language Support]
Visual F# is a new programming language which actually combines functional & object oriented programming to provide scalable language for .Net.

[Test Driven Development]
Visual Studio 2010 now offers greater support for test driven development where tests can be written before the actual code as an approach to the software design.

[Multi Targeting]
By using the multi targeting feature you can also create application of earlier version in new IDE of visual studio.

[Parallel Processing]
Using the new parallel extension of .Net 4.0 developers can create application which will scale efficiently as the number of cores & processors increase.

[Security]
The new framework improvements & expanded capabilities in the security model by simplifying the security policy. Now runtime support has been removed for enforcing the Deny, RequestMinimum, RequestOptional, and RequestRefuse permission requests.

[Performance]
.Net framework 4.0 beta 1 now provides improvement in the startup time and faster performance for multi threaded applications.

[Lazy Initialization]
By using this feature, the memory for an object is not allocated until it is needed. This improves the performance by spreading the object allocation across the lifetime of the application.

[In-Process Execution]
This enables an application to load & activate multiple version of the CLR inside the same process. Now you can run applications those are based on the .Net 2.0 & .Net 4.0 inside the same process.

[Profiler]
In the new framework you can now attach, run and detach profiling tasks at any point of time.

[Garbage Collection]
.Net Framework 4.0 now supports background garbage collection. In earlier frameworks it was a concurrent garbage collection.

[Collection & Data Structure]
- The new framework now includes BigInteger which supports all the standard numeric operation including the bit operation.
- It now supports self balancing SortedSet tree which sorts automatically after insert/delete operation.
- A new data structure named Tuple has been introduced in this framework which can hold an ordered set of heterogeneous items.

[Exception Handling]
The new CLR can now handle any exception regarding the corrupted state of the underlying operating system.

and more…

Recently, I was facing performance issue while working with huge data. I need to bind those data inside a panel as Custom User Control & want to change the properties multiple times in a second. When I used less no's of data it was working fine, but, when I tried with more no of data, my application starts crying. It was a real pain to the application to start while loading those records & unfortunately I didn’t get any solution to that.

After doing a lot of analysis with VirtualizingStackPanel concept that I shared in my previous post “What is Virtualizing StackPanel?” didn’t solve my problem which I was facing due to huge no of data.

Later, I found a very good post (“WPF: Adventures in Virtualization by Mike Taulty”) shared by Dr. WPF on implementing custom Virtual Panel, which actually resolved my problem.

Here you will find some very good articles on step-by-step implementation of Virtual Panel:

• BenCon's IScrollInfo in Avalon part I
• BenCon's IScrollInfo in Avalon part II
• BenCon's IScrollInfo in Avalon part III
• Dan Crevier's Implementing a virtualized panel in WPF part I
• Dan Crevier's Implementing a virtualized panel in WPF part II
• Dan Crevier's Implementing a virtualized panel in WPF part III
• Dan Crevier's Implementing a virtualized panel in WPF part IV

Those are very nice articles to implement the custom virtual panel step-by-step & after implementation of this panel, I noticed a huge performance improvement in my application. This really helped me while working with a huge records.

Now, come to the basic concept of this virtual panel. What it actually does. It loads all the records in a different thread & populate them in the UI as much as records that can be viewable in the screen. While scrolling, it actually creates new object of the elements by virtualizing the existing elements. So, only those objects will be in the memory which are available in the screen. The rest will go for a cleanup process. Hence, improving the performance more & more…. depending on the visible UI elements.

See a nice example in this location: http://blogs.msdn.com/jgoldb/attachment/8116217.ashx