Two friends decide to meet at a definite place between 9 AM and 10 AM. The first to arrive waits for his friend for 15 minutes and then leaves. If each of them arrives at an arbitrary moment between 9 and 10 AM, find the probability that they will meet.

First Step – Sample Space

We can treat this problem geometrically. The interval from 9:00 AM to 10:00 AM represents a segment of length 1. Let a unit length segment on the x axis represent one friend’s sample space. Let a unit segment on the y axis represent the other friend’s sample space. The total sample space is then an area of unit length squared. Every point in this unit square represents the arrivals of the two friends.

Geometric Interpretation of the condition

The events(x,y) during which the friends actually meet are given by the condition

(1)  

Solution

The intersection of the above band with the unit square gives us the required probability (7/16)

Related Problems

1. Two points A and B are thrown at random onto a unit segment of the x axis. Find the probability that the length of the segment will be smaller than the distance between the origin and the nearest point
2. Buffon’s needle problem –A plane is ruled with parallel straight lines a distance a apart. A needle of length l  where l < a  is thrown on the plane at random. Find the probability that the needle will hit any of the lines.

Up till now, Sonia Gandhi had maintained a distant silence. Her silence at least gave her the benefit of doubt. The hope that perhaps, somewhere in her mind, she saw the Hazare movement as a genuine attempt to tackle corruption. That benefit of doubt can no longer be extended to Mrs. Gandhi. She has come out with blazing guns – just like her son Rahul did a few weeks ago. Perhaps she forgets that the Hazare movement effectively ruined her son’s image – and has perhaps jeopardized his chances of ever becoming P.M. The lesson to be learnt here was that it wasn’t Anna versus Rahul. It was corruption crusaders versus opponents of the crusade. And the crusaders were not limited to Anna Hazare and his supporters. It included, in large part, all of India’s population – a unification feat that is not easy to replicate in a country as diverse as India. So – when Rahul came out in opposition to Anna Hazare, he came out in opposition to the Indian populace. He went instantly from ‘future PM’ to ‘just another politician’.

One would hope that Senior Congress leaders would have learnt their lesson from this fall of the mighty. Unfortunately, Sonia Gandhi is also treading the same swamp waters as her son. Her attack on Anna – no matter how compartmentalized it may be – will seem as an attack on Indians all over the world. She will witness the same fall from grace as her son. Not because she tried to tackle Anna – but because she failed to recognize the strength of his movement.  Because she tried to fool the Indian people with a watered down draft that even a 6 year old could see through.

Tragically, the only reason that Sonia could possibly be opposed to leaving the CBI out of the LokPal is the same reason as any other politician’s. To avoid going to jail! They know that giving this independent power to the CBI will result in some ‘big fish’ landing behind bars. In fact, without this power, the Lokpal bill is meaningless. Sonia realizes this as well as any other party member – and wants to dilute it.  This dilution effort is as good as a confession of guilt. Sonia has broken her silence – and with it her innocence.

Finally, I went to an orthopedic (who happens to be a friend of my father’s). He first explained why this was happening. Overuse. He then explained that every muscle in the hand and the wrist is connected to this same elbow joint. Which is why, when one develops tennis elbow – any movement from the hand-up hurts like hell. His advice was simple – give the elbow complete rest. By complete – he meant complete. Put it in a sling for a week and do not use it at all! Alternatively, if this was unacceptable, I could wear a special elbow brace. This would let me carry on mild daily activities (like computer keyboard) – but, instead of the elbow joint, the brace would absorb the impact.

On Surgery

An interesting thing the orthopedic told me was that surgery simply detaches the muscles from the elbow joint. Therefore – the pain goes away. Not an ideal solution.

On Prolotherapy

I know there are people who swear by this alternative treatment – but I have to say, it did not work for me. It seemed to numb the pain for a while (that was just the ultrasound gel). However, the next day onwards, I could sense no improvement. It is supposed to take a week to 2 weeks. Two weeks down the road, still no improvement. And since this was out of pocket, I felt a good $500 go down the drain for zero relief.

How do we get out of our own way?

Putting the action in perspective

This is best done by visualizing your life as a whole – and this particular act as a small part of that life stream. This helps put the action in perspective – and doesn’t let you get overpowered by the thought of performing it.

Putting fear in its own place

Chances are that whatever you are trying to do (that requires courage) is something that you enjoy doing (running your business, taking on a new challenge etc.). Try to get to a point where you see your love for the job overcoming the fears associated with it (fear of criticism, fear of failure etc.). That positivity helps put the fear ‘in its place’. Instead of overpowering you, the fear is relegated to just a ‘concern’ – not worth preventing you from undertaking your action.

Summary

Do you have important things to do – but find yourself afraid of getting started?  Try to figure out if you are getting in your own way or not. Chances are you probably are. Try to get out of your own way by putting the action in perspective – as well as your fear in its own place.

A Flash Mob consists of a group of dancers who come together (seemingly impromptu) and start performing. What do these people share (in addition to an obvious love for dance)? They have all overcome the fear of public display!  Think about it. You may be a good dancer – but chances are you would not be able to dance on a street full of people. To get to that stage, a certain fear needs to be overcome. This fear is primarily self-induced. In other words, you yourself are the main obstacle standing in your way. Once you get out of your own way, you tend to lose this fear. It helps to know that you are not alone – and others are going to be part of the same event. Still – the first step to being a flash mob performer is the conquest of this fear.

And while a flash mob performance appears to be an impromptu event, in reality, it is quite the contrary. Not only is event planned well in advance, but sufficient practice and rehearsals constitute part of the plan. The exact venue is always kept secret – and only shared with the media (to ensure coverage) as well as the police (to ensure security). The effect of this secretive mode of planning is that, on the d-day, it appears as a completely impromptu event. Which, in fact, adds to its appeal. The whole effect is that of –

wow – how could something so ad-hoc and unplanned be so eye-catching and well choreographed? These guys must be good!

What does this have to do with business events?

Businesses need to plan their events in a similar fashion. They need to plan diligently (rehearse the flash mob event), they need to create a sense of secrecy around it – and they need to pull off the event with perfection. Moreover, they need to overcome a certain fear – a fear of criticism – public criticism. Nothing ventured, nothing gained. One company that captured all of the above in all its releases is APPLE.  Each release of an apple product almost feels like a flash mob. Prior to a release, it has the same sense of excitement built on secrecy. Post release, it leaves everyone with the same wow factor as a flash mob event. Businesses can learn a few things from flash mobs – would you agree?

Business Data and Grids

Business data tends to organize itself into rows and columns (witness the success of Lotus123, Excel and other spreadsheet software).

Windows DataGridView

For the .NET UI developer, the Windows DataGridView is indispensible in that it provides a quick way to organize business data into rows and columns. Sorting, Paging etc. are usually either built in or fairly straightforward to implement. Going beyond the basic sorting (e.g. multiple column sort) or basic grouping (e.g. multiple column groups) calls for some serious investment in time. More importantly, as we shall see in this post, going beyond just a few 100 KBs of bound data, leads to serious performance degradation – making the DataGridView unsuitable for enterprise level grid/tabular data applications.

Object Binding

Object binding refers to the ability to bind a control to a custom data type (your domain objects). In pre-object binding days, one would bind a control directly to the raw data (e.g. an int CustomerID and a string CustomerName retrieved from the datasource). This was a cumbersome approach since most of the data could logically be grouped into custom data types (e.g. Customer). The User Interface was mainly interested in displaying the domain types (e.g. Customer) and less interested in native data types such as ints and strings. This led to the development of object-binding as an alternative to older raw data-binding.

A typical datagridview application that uses object binding will involve the following steps:

1. Fetching Data (usually using ADO.NET and a DataReader/DataTable/DataSet combination).
2. Storing the fetched data in a local collection (typically an IList<T> where T represents your custom domain object e.g. IList<Customer>).
3. Converting the IList<Customer> to a BindingList<Customer>
4. Binding the BindingList to the datagridview

For a detailed walkthrough of custom object binding to a datagridview, see this MSDN magazine article.

Bound versus Virtual Display Modes

By default, most datagridview developers use a Display mode called Bound. In this display mode, the data in the grid is automatically bound to the data in the datasource. This means that the grid view control handles all aspects of fetching the data as well as displaying the data. While this offers convenience, it is the main reason for slower display performance on the DGV. Fortunately, there is another display mode available to address this problem. This mode is known as the virtual display mode. In this display mode, instead of being bound to the entire datasource, the grid is essentially bound to a small subset (a cached portion) of the datasource. This small subset is the set of data should match the data that is visible on the grid (the exact amount of data is under the programmer’s control). Whenever a user wants to see more data (scrolls the grid), that data is fetched from the datasource, placed into cache – and returned to the grid from the cache. This way, only a small amount of data is ever bound to the grid – and even that only through a memory based cache.  This alleviates a lot of issues with the Windows DataGridView – including slow UI refreshes, locked UIs etc.

Windows DataGridView’s Virtual Display Mode

// Enable virtual mode.


            this.dataGridView1.VirtualMode = true;

            // Connect the virtual-mode events to event handlers. 

            this.dataGridView1.CellValueNeeded += new

                DataGridViewCellValueEventHandler(dataGridView1_CellValueNeeded);

          

While the DataGridView control is flexible enough to display any IList as its datasource, it starts running into some performance problems for large volumes of data. The Virtual mode in the Windows DataGridView control was designed for just such a purpose – to handle refreshes of large volumes of data. It does this by postponing the rendering of the entire data all at once – and only renders a fixed number of rows and columns at a time. As one tries to scroll down (or up), new data is rendered at that very instant – using predefined events (CellValueNeeded event in the DataGridView).

For even larger volumes of data..

  While the virtual display mode in the DataGridView offers an option to display lots of data without slowing down refresh rates, even this powerful mode starts showing sluggishness for larger amounts of data (several hundred MBs of data). What is one to do if one needs to continue displaying data in a grid – and the underlying datasource consists of several hundred(s) MBs of data?

Enter Syncfusion

  Syncfusion is a 3rd Party UI library – which contains several advanced controls in its toolbox. It offers a GridControl with all the basic grid display capabilities. In addition to the basic gridcontrol,  it offers something called a GridGroupingControl – which is a GridControl on steroids. (NOTE: The difference between the GridGroupingControl and the GridControl in Syncfusion is basically in the set of features – the GridGroupingControl has a richer set of features. Performance-wise, they are both comparable). The rest of this post summarizes some of my initial experiences as a Syncfusion developer – both in terms of performance as well as built-in capabilities.

Syncfusion Grid Grouping Control Features:  Grouping by Multiple Columns, Nested Grids (Hierarchical data)

For instance, if one is interested in grouping by not one – but multiple columns, the grouping grid does it with just a couple of lines of code. If one is interested in nested grids (to display hierarchical data for example), Syncfusion’s GridGroupingControl provides that out of the box as well (see screenshot above). Note that one can build the same nested table functionality in the Windows DataGridView (using the example shown here). If one is interested in sorting by more than one column, Syncfusion GridGroupingControl provides that out of the box as well (whereas one needs to custom build this in the Windows DataGridView as shown in this article).

Syncfusion Grid Control (and Grid Grouping Control)  – Performance

  However, the main reason our team chose Syncfusion was simple – performance. Syncfusion provides a GridControl class which also has a virtual mode built in.  The virtual mode in Syncfusion’s GridControl works in a similar fashion to Windows DataGridView – by rendering more rows and columns as the user tries to scroll up or down on the grid. The actual events that Syncfusion uses are QueryCellInfo and QueryRowCount (full source code available at the of this post). The snippet below shows the main events that the gridControl needs to have handled.

            // Enable virtual mode.

            this.dataGridView1.VirtualMode = true;

            this.gridControl1.QueryCellInfo += new Syncfusion.Windows.Forms.Grid.GridQueryCellInfoEventHandler(this.gridControl1_QueryCellInfo);

            this.gridControl1.QueryRowCount += new Syncfusion.Windows.Forms.Grid.GridRowColCountEventHandler(this.gridControl1_QueryRowCount);

Sample Experiment – Comparing Refresh Rates – DataGridView versus Syncfusion Grid

  The source code (included below) uses a simple ArrayList (of Customer objects) – and lets you experiment with the performance of the DataGridView as the number of objects grows. In the sample code, the list of Customers is set to a size of 10,000. At this size, the performance difference between the Windows DatagridView and Syncfusion’s GridControl are already visible. If you try a larger size list, the differences will be even more evident.

Load Time versus Rendering Time

The real test of how fast data is displayed on the grid – is the rendering time. We are less concerned here with the data retrieval time (for e.g. – retrieving data from an ADO.NET source) – than with the time it takes to display thousands of rows of data.  When one runs the two grids (WinForms dgv and Syncfusion’s gridcontrol) side by side, for the same set of data (see the sample solution below), one can see by just plain visual inspection, the Windows DataGridView renders a lot slower than Syncfusion’s GridControl.

Summary

This article (based on my experience as a Syncfusion developer) shows a side by side performance experiment of the WinForms DataGridView and Syncfusion’s GridControl. Using each of these grids to display the exact same data (10,000 unique customer data records), one can see the different rendering speeds. WinForms’ DataGridView starts deteriorating in performance at just a few hundred KBs of display data – in spite of using its own fastest display mode – the virtual display mode.

 Syncfusion’s GridControl offers a faster (superfast) alternative to the WinForms DataGridView. In addition to speed, the grid control offers sophisticated data manipulation features such as nested grids (nested tables), pivot tables, multiple column sorts etc. Other vendors (Infragistics, Telerik etc.) offer similar grid controls, however, in our initial performance centric comparisons, syncfusion’s grid control seemed to be a clear winner. The choice of Syncfusion mentioned above is somewhat biased – as my experience as a Syncfusion developer is more extensive than as a Telerik or Infragistics developer.

If your business data is in the hundreds of MBs (as ours was) and needs to be bound to UI controls, chances are you will outgrow the built-in WinForms controls very quickly. You will need to start looking at 3rd party vendors like Syncfusion and Infragistics to provide you with the UI performance that your application needs.

Source Code

Download Source Code (Need to download and install Syncfusion Essential Studio Windows Forms Edition 7.3.X or above) 

About the Author

  Anuj Varma is a Microsoft .NET architect specializing in high-performance applications. His specific expertise in the .NET framework architecture as well as 3rd party controls (Syncfusion development) built around the framework,  makes him a sought after performance expert for .NET applications.  Anuj’ experience as a Syncfusion developer makes him a sought after Syncfusion expert. He continues to specialize in Syncfusion’s Essential Suite for building sophisticated web and desktop applications. Most recently, he has worked on an ASP.NET revamp of dell.com as well as a WinForms app used to map Ocean floors (Petrel). Both these applications were built with performance (UI performance as well as Data Access Layer performance) as a key driver.

An object-bound datagridview

Object binding refers to the ability to bind a control to a custom data type (your domain objects). In pre-object binding days, one would bind a control directly to the raw data (e.g. an int CustomerID and a string CustomerName retrieved from the datasource). This was a cumbersome approach since most of the data could logically be grouped into custom data types (e.g. Customer). The User Interface was mainly interested in displaying the domain types (e.g. Customer) and less interested in native data types such as ints and strings. This led to the development of object-binding as an alternative to older raw data-binding.

A typical datagridview application that uses object binding will involve the following steps:

1. Fetching Data (usually using ADO.NET and a DataReader/DataTable/DataSet combination).
2. Storing the fetched data in a local collection (typically an IList<T> where T represents your custom domain object e.g. IList<Customer>).
3. Converting the IList<Customer> to a BindingList<Customer>
4. Binding the BindingList to the datagridview

For a detailed walkthrough of custom object binding to a datagridview, see this MSDN magazine article.

Bound Display Mode

For object bound DGVs (datagridviews), the ‘Bound’ mode is the most commonly used display mode. In this mode, the datagridview control is automatically bound to the source of the data – and any changes to the source of the data cause refreshes of the various UI elements of the grid (columns, rows etc.). This offers a degree of convenience that is appealing, at least for small volumes of data. This Bound mode kicks into effect whenever you set the Datasource property on the  datagridview as shown in the snippet below.

The Problem with Bound display mode

The first indications of problems with the bound mode are visible as soon as you start adding additional items to the source list (while the grid is bound to it). Note that it is possible to add additional items without binding the grid – and then performing the binding step at the very end – as shown in the snippet above. However, even with this approach, at some point, you may need to add/delete items from the source list – causing unnecessary refreshes. More serious problems with the DataGridView start manifesting themselves as the size of the bound collection grows. For larger sets of data, this problem grows to unacceptable response times.

Enter Virtual Mode

By default, most datagridview developers use a Display mode called Bound. In this display mode, the data in the grid is automatically bound to the data in the datasource. This means that the grid view control handles all aspects of fetching the data as well as displaying the data. While this offers convenience, it is the main reason for slower display performance on the DGV. Fortunately, there is another display mode available to address this problem. This mode is known as the virtual display mode. In this display mode, instead of being bound to the entire datasource, the grid is essentially bound to a small subset (a cached portion) of the datasource. This small subset is the set of data should match the data that is visible on the grid (the exact amount of data is under the programmer’s control). Whenever a user wants to see more data (scrolls the grid), that data is fetched from the datasource, placed into cache – and returned to the grid from the cache. This way, only a small amount of data is ever bound to the grid – and even that only through a memory based cache.  This alleviates a lot of issues with the Windows DataGridView – including slow UI refreshes, locked UIs etc.

Quick Conversion from bound to virtual (full source code at the end of this post)

In your source code, if you are using the bound display mode (happens by default if you set the ‘datasource property) you will be setting the datasource property on your gridview somewhere – e.g.

Instead of setting this datasource property, what you will need to do is initialize the grid to use virtual mode. This is shown in the snippet below (full source code included at the end of this post).

The actual dataGridView1_CellValueNeeded event is where the event to request more data is handled.  The included source code below provides a quick implementation of the virtual display mode – which should work for simple use cases. For a full walkthrough on a virtual mode implementation, see MSDN.

What if the Virtual Mode is still sluggish?

If the performance of virtual mode is still sluggish for your data (if you have several thousands of rows of data), chances are you need to look elsewhere. There are several 3rd party grid controls on the market – including Infragistics, Syncfusion and Telerik. One such grid that I have worked with extensively is Syncfusion’s Grid Control. On my project, we were handling several hundred MBs of data in the grid – with refreshes occurring in real-time or near real-time (i.e. no sluggishness).  A performance comparison is detailed in an earlier post.

In addition to the speed, you also get a host of features that I like to call Grid on Steroids features. These include nested grids (which make it possible to efficiently display hierarchical data), multiple column sorts (which isn’t available out of the box in Windows DataGridView – but can be custom built), pivot tables and more.

Summary

If you are witnessing slow rendering (sluggish rendering) of your datagridview in your WinForms (or ASP.NET ) application, chances are you are using automatic binding (bound display mode). Chances are that you will experience a significant benefit from trying the virtual display mode built into the gridview. This display mode binds to a smaller, cached subset of the full data, allowing quicker UI refreshes. The sample attached here shows a grid using the bound mode and another grid using virtual mode (both with identical 10000 rows of customer data). Even with this simple sample of a few 100 KBs of data, a noticeable difference can be seen (by visual inspection) when one tries to scroll down the grid to view more rows. The refresh rate of the virtual mode grid clearly wins out.  If you find the virtual mode also insufficient for your application’s volume of data, you might need something like the syncfusion grid.

Source Code

Download Full Solution

About the Author

  Anuj Varma is a Microsoft .NET architect specializing in high-performance applications. His specific expertise in the .NET framework architecture as well as 3rd party controls (such as Syncfusion) built around the framework,  makes him a sought after performance expert for .NET applications. Most recently, he has worked on an ASP.NET revamp of dell.com as well as a WinForms app used to map Ocean floors (Petrel). Both these applications were built with performance (UI performance as well as Data Access Layer performance) as a key driver. In addition to WinForms and ASP.NET apps, Anuj works hands-on in the WCF and Azure arena to bring performance to existing SOA apps. Some of Anuj’s personal websites include anujvarma.com,  AspDotnetArchitect.com and RecruitersToAvoid.com.

Business Data and Grids

Business data tends to organize itself into rows and columns (witness the success of Lotus123, Excel and other spreadsheet software).

Windows DataGridView

For the .NET UI developer, the Windows DataGridView is indispensible in that it provides a quick way to organize business data into rows and columns. Sorting, Paging etc. are usually either built in or fairly straightforward to implement. Going beyond the basic sorting (e.g. multiple column sort) or basic grouping (e.g. multiple column groups) calls for some serious investment in time. More importantly, as we shall see in this post, going beyond just a few 100 KBs of bound data, leads to serious performance degradation – making the DataGridView unsuitable for enterprise level grid/tabular data display centric applications.

Object Binding

Object binding refers to the ability to bind a control to a custom data type (your domain objects). In pre-object binding days, one would bind a control directly to the raw data (e.g. an int CustomerID and a string CustomerName retrieved from the datasource). This was a cumbersome approach since most of the data could logically be grouped into custom data types (e.g. Customer). The User Interface was mainly interested in displaying the domain types (e.g. Customer) and less interested in native data types such as ints and strings. This led to the development of object-binding as an alternative to older raw data-binding.

A typical datagridview application that uses object binding will involve the following steps:

1. Fetching Data (usually using ADO.NET and a DataReader/DataTable/DataSet combination).
2. Storing the fetched data in a local collection (typically an IList<T> where T represents your custom domain object e.g. IList<Customer>).
3. Converting the IList<Customer> to a BindingList<Customer>
4. Binding the BindingList to the datagridview

For a detailed walkthrough of custom object binding to a datagridview, see this MSDN magazine article.

Bound versus Virtual Display Modes

By default, most datagridview developers use a Display mode called Bound. In this display mode, the data in the grid is automatically bound to the data in the datasource. This means that the grid view control handles all aspects of fetching the data as well as displaying the data. While this offers convenience, it is the main reason for slower display performance on the DGV. Fortunately, there is another display mode available to address this problem. This mode is known as the virtual display mode. In this display mode, instead of being bound to the entire datasource, the grid is essentially bound to a small subset (a cached portion) of the datasource. This small subset is the set of data should match the data that is visible on the grid (the exact amount of data is under the programmer’s control). Whenever a user wants to see more data (scrolls the grid), that data is fetched from the datasource, placed into cache – and returned to the grid from the cache. This way, only a small amount of data is ever bound to the grid – and even that only through a memory based cache.  This alleviates a lot of issues with the Windows DataGridView – including slow UI refreshes, locked UIs etc.

Windows DataGridView’s Virtual Display Mode

// Enable virtual mode.


            this.dataGridView1.VirtualMode = true;

            // Connect the virtual-mode events to event handlers. 

            this.dataGridView1.CellValueNeeded += new

                DataGridViewCellValueEventHandler(dataGridView1_CellValueNeeded);

          

While the DataGridView control is flexible enough to display any IList as its datasource, it starts running into some performance problems for large volumes of data. The Virtual mode in the Windows DataGridView control was designed for just such a purpose – to handle refreshes of large volumes of data. It does this by postponing the rendering of the entire data all at once – and only renders a fixed number of rows and columns at a time. As one tries to scroll down (or up), new data is rendered at that very instant – using predefined events (CellValueNeeded event in the DataGridView).

For even larger volumes of data..

  While the virtual display mode in the DataGridView offers an option to display lots of data without slowing down refresh rates, even this powerful mode starts showing sluggishness for larger amounts of data (several hundred MBs of data). What is one to do if one needs to continue displaying data in a grid – and the underlying datasource consists of several hundred(s) MBs of data?

Enter Syncfusion

  Syncfusion is a 3rd Party UI library – which contains several advanced controls in its toolbox. It offers a GridControl with all the basic grid display capabilities. In addition to the basic gridcontrol,  it offers something called a GridGroupingControl – which is a GridControl on steroids. (NOTE: The difference between the GridGroupingControl and the GridControl in Syncfusion is basically in the set of features – the GridGroupingControl has a richer set of features. Performance-wise, they are both comparable)

Syncfusion Grid Grouping Control Features:  Grouping by Multiple Columns, Nested Grids (Hierarchical data)

For instance, if one is interested in grouping by not one – but multiple columns, the grouping grid does it with just a couple of lines of code. If one is interested in nested grids (to display hierarchical data for example), Syncfusion’s GridGroupingControl provides that out of the box as well (see screenshot above). Note that one can build the same nested table functionality in the Windows DataGridView (using the example shown here). If one is interested in sorting by more than one column, Syncfusion GridGroupingControl provides that out of the box as well (whereas one needs to custom build this in the Windows DataGridView as shown in this article).

Syncfusion Grid Control (and Grid Grouping Control)  – Performance

  However, the main reason our team chose Syncfusion was simple – performance. Syncfusion provides a GridControl class which also has a virtual mode built in.  The virtual mode in Syncfusion’s GridControl works in a similar fashion to Windows DataGridView – by rendering more rows and columns as the user tries to scroll up or down on the grid. The actual events that Syncfusion uses are QueryCellInfo and QueryRowCount (full source code available at the of this post). The snippet below shows the main events that the gridControl needs to have handled.

            // Enable virtual mode.

            this.dataGridView1.VirtualMode = true;

            this.gridControl1.QueryCellInfo += new Syncfusion.Windows.Forms.Grid.GridQueryCellInfoEventHandler(this.gridControl1_QueryCellInfo);

            this.gridControl1.QueryRowCount += new Syncfusion.Windows.Forms.Grid.GridRowColCountEventHandler(this.gridControl1_QueryRowCount);

Sample Experiment – Comparing Refresh Rates – DataGridView versus Syncfusion Grid

  The source code (included below) uses a simple ArrayList (of Customer objects) – and lets you experiment with the performance of the DataGridView as the number of objects grows. In the sample code, the list of Customers is set to a size of 10,000. At this size, the performance difference between the Windows DatagridView and Syncfusion’s GridControl are already visible. If you try a larger size list, the differences will be even more evident.

Load Time versus Rendering Time

The real test of how fast data is displayed on the grid – is the rendering time. We are less concerned here with the data retrieval time (for e.g. – retrieving data from an ADO.NET source) – than with the time it takes to display thousands of rows of data.  When one runs the two grids (WinForms dgv and Syncfusion’s gridcontrol) side by side, for the same set of data (see the sample solution below), one can see by just plain visual inspection, the Windows DataGridView renders a lot slower than Syncfusion’s GridControl.

Summary

This article shows a side by side performance experiment of the WinForms DataGridView and Syncfusion’s GridControl. Using each of these grids to display the exact same data (10,000 unique customer data records), one can see the different rendering speeds. WinForms’ DataGridView starts deteriorating in performance at just a few hundred KBs of display data – in spite of using its own fastest display mode – the virtual display mode.

 Syncfusion’s GridControl offers a faster (superfast) alternative to the WinForms DataGridView. In addition to speed, the grid control offers sophisticated data manipulation features such as nested grids (nested tables), pivot tables, multiple column sorts etc. Other vendors (Infragistics, Telerik etc.) offer similar grid controls, however, in our initial performance centric comparisons, syncfusion’s grid control seemed to be a clear winner.

If your business data is in the hundreds of MBs (as ours was) and needs to be bound to UI controls, chances are you will outgrow the built-in WinForms controls very quickly. You will need to start looking at 3rd party vendors like Syncfusion and Infragistics to provide you with the UI performance that your application needs.

Source Code

Download Source Code (Need to download and install Syncfusion Essential Studio Windows Forms Edition 7.3.X or above) 

About the Author

  Anuj Varma is a Microsoft .NET architect specializing in high-performance applications. His specific expertise in the .NET framework architecture as well as 3rd party controls (such as Syncfusion) built around the framework,  makes him a sought after performance expert for .NET applications. Most recently, he has worked on an ASP.NET revamp of dell.com as well as a WinForms app used to map Ocean floors (Petrel). Both these applications were built with performance (UI performance as well as Data Access Layer performance) as a key driver. In addition to WinForms and ASP.NET apps, Anuj works hands-on in the WCF and Azure arena to bring performance to existing SOA apps. Some of Anuj’s personal websites include anujvarma.com,  AspDotnetArchitect.com and RecruitersToAvoid.com.

The Issue : Visual Studio throws the following compile time error on a project that includes UI controls (either WinForms or ASP.NET controls).

The item was specified more than once in the resources parameter. Duplicate items are not supported by the “Resources” .

Solution: Simply open up the .csproj file – and look for the occurence of the particular resource  (item). This resource item name appears in the exact compiler error. In my case, the resource name was SyncfusionVirtualGrid – and my .csproj contained an entry such as:

  <EmbeddedResource Include="SyncfusionVirtualGrid.resx">

      <DependentUpon>SyncfusionVirtualGrid.cs</DependentUpon>

    </EmbeddedResource>

  

Remove this entry from the .csproj file (Alternatively, you can just right click on the .resx file – and delete it from there).

This should resolve the compilation error.