Dapfor

Hierarchical .Net Grid v.2.6.2

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

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.

Grid and Treelist

Grid and treelist. Easy to build any hierarchy. Single and multiple headers.

The Highest Performance

The highest performance. Low consumption of CPU and memory resources. Benchmark details.

Diagnostic Tools

Diagnostic Tools. Useful and convenient debugging tools, business logic inspection.

The Highest Quality

Various types of binding. Hierarchical and declarative binding at any hierarchy level. Simultaneous work with bound and unbound data.

Awards

From the Blog

Correct organization of event processing in a separate thread

Multithreaded application became something common. The main reason for that is execution of resource-intensive tasks in parallel to GUI without stopping it for long operations. As it is well known, the easiest way for asynchronous data processing used by ThreadPool. This method is not only the easiest, but also very efficient. Notwithstanding its merits, it [...]

How to avoid exceptions upon exiting application

Almost every modern application is multi-threaded. Threads are needed to work with various devices and IP protocol stack and to perform demanding computing operations. Results of work performed in these threads should be displayed in graphical controls. Control.Invoke / Control.BeginInvoke are the main methods used for thread synchronization. These methods work excellent only when control [...]

Performance of synchronization with GUI thread

It is well known that all graphical controls should work in one thread. There are many articles on this subject, so we shall not repeat them. In multi-threaded applications every call should be synchronized with the main thread containing windows message loop. Control is a base class that provides Control.Invoke and Control.BeginInvoke methods. The first [...]

.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