Dapfor .Net Grid. Grouping, Editors, 50000 updates/sec. Low CPU and memory consumption.

Hierarchical .Net Grid v.2.8.0

Hierarchical data presentation. Single or multiple headers.
Real-time row grouping, sorting, filtration, cell highlighting.
Rich custom cell editors and standard editors used in the PropertyGrid.
Ultimate performance: > 50 000 cell updates/second.
Thread-safe implementation. No deadlock risks.
XML and binary serialization.
High quality, 370+ NUnit tests

Performance

High insertion rate: > 100 000 rows/second
High removal rate: > 600 000 rows/second
High grouping rate: > 60 000 rows/second
Regrouping rate: > 10 000 rows/sec in a grid of 5000 rows
Filtering rate: > 7 000 rows/sec in a grid of 5000 rows
Sorting rate: > 5 000 sorts/sec in a grid of 5000 rows
Data updating with highlighting: > 50 000 cells/second
Low memory consumption: ~ 16 MB for grid of 100 000 rows
Measure .Net Grid performance on your computers

Data Binding

Binding to IList, IBindingList, IListSource
Binding to multiple sources simultaneously
Declarative hierarchical binding
Binding to IList and IBindingList in any Row
Conditional binding
Ability to use bound and unbound objects together

Data Types

Objects of arbitrary classes
String or object arrays (string[], object[])
Objects implementing IEnumerable and IList interfaces
Objects implementing IDictionary < string, object >
Virtual data

Dynamic Data

Easy data highlighting with Cell.Highlight(color, interval)
High-performance sorting of dynamically changing data
Automatic regrouping of data changing in real-time
Automatic filtering in real-time mode

Data Editing

Standard controls for editing cell content
Expanded controls (e.g. slider or rating editor)
Any other controls for data editing
Data validation

Grid Customization

UI filters in columns for content filtering
Non-scrollable columns
Unsorted docked rows
Alternative row colors
Cell tooltips

Hierarchy

TreeList and grid with independent headers within a single component
Simple and intuitive creation of any hierarchy in the grid
Ability to use multiple IBindingList objects for hierarchy creation
Declarative and сonditional hierarchy creation
Use of different object types at one hierarchy level

Drag & Drop

Moving data inside a grid or between grids
Hierarchical drag & drop operations preserving child structures
Data import and export between applications with drag & drop feature
Full control over drag&drop process

Data Grouping

Single and multiple grouping
Real-time data regrouping upon change
Combined filtering and sorting of grouped data
High performance with large data volumes

Thread Safety

Safe to add, delete and modify data
Systematic thread synchronization upon INotifyPropertyChanged and IBindingList notifications
Different thread synchronization models upon notification: with or without blocking of the caller thread
Data model represented by IBindingList can operate in any thread

Unique Features

Semi-transparent selection of rows and cells preserving their background
Simple cell highlighting with Cell.Highlight(color, interval)
Highest performance of operations with dynamically changed data
Thread safety

Reporting

Software control of reporting with full customization support.
Possibility of adding any images or text to printed pages.
Page spanning: If there are too many fields to fit on one page, the fields can span two or more pages.
Repeating headers: to improve document readability the grid can insert headers to every printed page.
Hiding headers in reports
Print preview feature
Portrait or landscape page orientation

Quality

Number of tests: > 370
Percentage of testing code in software: > 30%
Coverage of data level with tests > 65 %
Coverage of thread-safety routines with tests: > 84 %
Coverage of algorithms (sorting, grouping, etc) > 65 %

The latest hardware is not made for being slow down by our competitors' grids!

The most powerful .Net Grid

Net Grid is the best performing grid on the market adapted for real-time applications and displaying huge data volumes. Thread protection makes it safe to use with MVVM model. Learn more on how to build high-performance applications.

The Highest Performance

Low consumption of CPU and memory. .NetGrid supports > 50 000 updates/sec. Download demo.

Grid and treelist in one component

Easy to build any hierarchy. Single and multiple headers. Data binding at any hierarchical level

Rich editors

Editing data in a drop-down combo box or in a cell with any control. Standard and custom editors.

Diagnostic Tools

Useful and convenient debugging tools, business logic inspection.

Awards

From the Blog

.Net performance. Practical recommendations

Even the best performing component can be hindered by incorrect use. Below we provide practical recommendations on what should be used or avoided in application programming. Following the tips below you will be able to create applications with the same efficiency as this demo application. We also provide source codes for this example to show [...]

.NetGrid v2.8.0 has been released. RTL support, performance improvements

We are happy to announce that a new grid version is out. The version 2.8.0 of .Net Grid has a lot of new performance improvements and new features. Performance improvements Significantly improved BindingList performance, especially with objects implementing INotifyPropertyChanged interface. Here you may learn about causes of poor performance and methods for performance improvement. Significantly [...]

Why BindingList is slow with objects implementing INotifyPropertyChanged interface

A BindingList<T> is the main tool for binding objects to grids. It is a container that may notify subscribers when data is added or removed. For this purpose it provides public ListChanged event that specifies collection changes with ListChangedType. Besides changing the collection itself (adding, removing, etc) the binding list notifies of data object changes. [...]

.Net Grid Advantages

Unlike competitor grids that mainly work with static data, Dapfor grids can be used in real-time applications with both static and dynamic data. Well designed architecture and optimized use of CPU and memory resources guarantee the highest performance.

Broad data binding features. Simultaneous use of multiple data sources, binding at any hierarchy level, declarative hierarchical binding, conditional binding, simultaneous work with bound and unbound data, and many other features.

All Dapfor's products are thread-safe. This means that grids can be safely bound to any data source and receive notifications from any thread via IBindingList and INotifyPropertyChanged interfaces.

Products

Demo

Support