The grid was initially designed for electronic financial markets with their stringent requirements to robustness, low consumption of memory and CPU resources, ergonomic and simple user interface and rich API. These requirements share a common objective - to gain the first place on the market, to improve development time and to ensure productive work in run-time. As the result, we have created the most productive and robust hierarchical grid with one of the best object models. It can be used in a great variety of applications (not just for financial markets). It makes software user-friendly, reduces CPU and memory consumption and considerably accelerates development time with multiple services included in the grid and RAD (rapid application development) patterns.
- Frameworks : 2.0, 3.0, 3.5, 4.0 and higher
- Written entirely in managed C#
- Comprehensive documentation with many samples, integrated with Visual Studio
- Design time integration
Objects of arbitrary classes
Lists implementing IList interfaces, object or string arrays: object or string
Objects with variable number of fields: IDictionary<string, object>
Objects with variable number of fields capable to notify the grid of data changes
Simultaneous use of objects of different types in the grid
Binding grid to standard data sources (IList, IBindingList, DataTable, DataSet)
Simultaneous binding to multiple data sources (such as IList or IBindingList)
Simultaneous use of data of one or several types in one collection or in different collections at single or multiple hierarchy levels
Binding any row to data source (IBindingList or List) enabling use of object collections at any hierarchy levels
Unbound rows can be added without binding the grid to collections
Simple addition of unbound rows at any hierarchy level
Simultaneous use of unbound rows and grid binding to collections at single or multiple hierarchy levels
Declarative binding supports creation of complex hierarchies with simple tools
Declarative binding that combines data of different objects and makes it possible to avoid intermediate classes (classes that have only one purpose – to combine properties of objects of different classes to present combined data in the grid)
Conditional binding supports modification of data hierarchy (i.e. adding or removing intermediate hierarchy levels) at the time of binding
Building a hierarchy of tables linked with DataRelation
Can use data that implements INotifyPropertyChanged interface, can handle events of these objects
Independency of data source type: data implementing INotifyPropertyChanged interface may be stored in IList/IBindingList collections or may be added with any other method (e.g. with Grid.Rows.Add()/Row.Add() methods)
Automated highlighting of cells containing values that were modified during specified time interval with specified color (both can be easily changed)
Automated sorting of rows containing objects that fired a notification
Automated regrouping of grid data if needed. Changes concern only rows that contain objects that fired a notification. This feature significantly reduces CPU resource consumption.
Automated filtering for dynamic data
No dependency on object types implementing INotifyPropertyChanged interface. Possibility of simultaneous use of objects of different types.
Thread-safe processing of notifications received from INotifyPropertyChanged and IBindingList interfaces
High speed of data processing. Full-screen grid with 3 000 elements can handle over 50 000 notifications per second with simultaneous cell highlighting.
Simple and intuitive data filtering interface
Data filtering at any hierarchy level
Data filtering with or without sorting
Data filtering with or without grouping
Simple data filtering interface for automated filtering in real time when the grid connects to IBindingList (data is added, removed or modified) or use of event-driven model when objects implement INotifyPropertyChanged interface
Simultaneous data filtering, sorting and grouping at any hierarchy level
Possibility of implementing graphical filters in columns using any graphical controls. For example, it can be any user control or a trackbar that dynamically filters content on thumb position change.
High filtering speed. The grid with 7 000 rows supports over 5 000 filtering operations per second.
Grouping by one or multiple columns
Grouping at any hierarchy level, not just at the top level
Simultaneous grouping of multiple headers at different hierarchy levels
Supported of sorting in grouped columns
Simultaneous use of data filtering and grouping, including use of graphical filters in columns
Support of program group creation
Automated data regrouping upon getting notifications from IBindingList or INotifyPropertyChanged interfaces
The same intuitive API for grouping static data and dynamic real-time data
High grouping speed: a grid of 10 000 elements can be grouped in 100 milliseconds. The grid of 10 000 elements can perform 5 000 real-time data regrouping operations per second.
Simple sorting interface
Sorting objects of different types
Different grids connected to the same data collection can use different sorting
Sorting by unformatted values (i.e. if a data object contains DateTime value, the grid compares values of this type instead of displayed strings). This prevents row comparison errors and significantly speeds up the sorting process.
Sorting data at different hierarchy levels
Support of creating custom sorting rules with a simple API
Automated sorting of data stored in IBindingList or data implementing INotifyPropertyChanged interface in event-driven model
Simultaneous data sorting, grouping and filtering
Docked rows that can always stay on top or at the bottom of their hierarchy level irrespective to data sorting. These rows can be used to display analytical information or information that should always be displayed on top or at the bottom irrespective to sorting.
High speed of sorting, including real-time data sorting. A grid of 5 000 rows can perform over 5 000 sorting operations per second.
Supports dynamic data highlighting for the specified period of time with predefined color. Supports semi-transparent colors.
Progressive color change during highlighting time
Highlights with one color for all time to save CPU resources
Supports highlighting with different colors using different color intensiveness for different cells
Simple and intuitive interface: calling Cell.Highlight(TimeSpan, Color) to highlight a cell
Automated highlighting upon receiving notifications from INotifyPropertyChanged and IBindingList interfaces
High performance and low CPU and memory consumption
Specialized algorithms to save memory when storing data on highlighted cells, colors and time periods
Possibility of using the grid either as a tree-list view with one header or as a control with multiple independent headers without modifying data.
Possibility of stretching columns over the entire grid width at any hierarchy level. If columns in all headers are stretched, horizontal scrolling becomes invisible.
Possibility of joining columns into groups. Every group can display text, images or any other content desired by the programmer on top of merged columns.
Possibility of setting any number of freezed columns at any hierarchy level. Freezed columns are always visible and are not involved in horizontal scrolling.
Bound and unbound columns
Dynamic replacing/adding/removing headers without data replacement (every header has information of columns, sorting, grouping, etc).
Grouping by one or multiple columns. Grouping can simultaneously be used in multiple headers.
Single or multiple data sorting on one or different hierarchy levels
Full customization of column and header painting.
Use of graphical filters in columns
Independent control of header visibility at different hierarchy levels
Repeating child headers before the first row in data hierarchy (headers can also be hidden)
Possibility of using and modifying context menu for any header and columns. This context menu will be independent of context menu used for data
User can drag & drop columns, modify column side, move, group or sort them via UI. Any of these features can be blocked by programmer.
Serialization of header state with columns and their location, dimensions, visibility or grouping to binary or xml archive
Editing data in a drop-down combo box with any user control
Any controls can be used as editors situated directly above the edited cell
Modal user forms can be used as editors (e.g. font picker)
Support of standard editors based on UITypeEditor (such as ColorEditor, FontEditor and many others) that are a part of standard Microsoft library
Support of third-party editors inheriting from UITypeEditor
Navigation (Tab, Shift+Tab, etc.) between editors during editing
Validation of user input during editing
Support of data editing with RTL
Actual data editing control can be created only for the time of editing. At all other times the grid can just paint it in cells (Example: TrackBar editor). This greatly improves performance when working with large data volumes.
Displaying hot frame around cell where the user can edit data
Broad appearance management features for virtually all grid elements
Setting appearance independently for the grid, different hierarchy levels, even or odd rows
Re-definition of appearance when painting graphical elements
Full or partial painting of graphical elements
Support of standard Microsoft themes, their centralized use for all grids in the application or for each grid individually
Support of theme customization and creation
Selection and navigation
Semi-transparent row selection without hiding cell background. Simple and clear selection display
Different selection modes: single and multiple
Support of working in row selection mode or cell selection mode
Support of lasso selection
Program-based selection control
Standard navigation with Up/Down/Left/Right/PageUp/PageDown/Home/End/Space keys. Support of program-based navigation
Well-designed shortcuts simplifying work with data. Most of shortcuts are based on standard Microsoft control behavior, e.g. keyRight opens a hierarchy and keyLeft closes it.
Mouse wheel scrolling
Simple methods for displaying content in visible grid area: Row.EnsureVisible()/Column.EnsureVisible()
Drag&drop support within one or several grids
Data hierarchy definition during drag&drop
Data transfer at the same hierarchical level or between different levels and between grids
Correct data transfer between grids that have different sorting, filtering or grouping
Selection of drag&drop content, full control of drag&drop operation with various standard effects
Data transfer between applications with serialization and deserialization. A programmer can decide how should data be serialized or deserialized.
Support of drag&drop to/from Word, Excel and other applications.
Special indicators show where and how shall be data inserted to the grid.
Serialization of appearance, headers, columns to binary or xml archive
Independent serialization of the entire grid or grid elements
Storing grid state (sorting, grouping, column position, dimensions, visibility, etc) in memory and restoring it at later time
Transferring grid states (headers, columns, sorting, etc) between grids
New grid versions support archives created by previous versions
- 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.
- Reports for top-level headers and child headers with relevant content.
- Hiding headers in reports
- Repeating selectors: if content has many columns, the grid can span it over multiple pages. This feature can insert row selector to every page.
- Print preview feature
- Portrait or landscape page orientation
Thread-safe operations of adding, removing and modifying data
IBindingList and INotifyPropertyChanged interfaces are thread-safe. The working thread is automatically synchronized with GUI thread upon notification from these interfaces.
Grids created in different threads (when multiple message loops are used) perform required thread synchronization upon receiving notifications from IBindingList and INotifyPropertyChanged interfaces.
Thread-safe sorting, grouping and filtering
The grid supports synchronous and asynchronous models of data synchronization on receiving notifications from INotifyPropertyChanged interface
Programmer can define his method of synchronizing data with graphical interface
Other grid features
- Share the same data source between different grids with various hierarchies, editors and appearance
- Rich API to determine row position in the grid. (visible position, position in hierarchy, parent row, children, filtration etc.)
Rich data formatting
Easy API to repaint any part of .Net Grid
Support of grid cell tooltips
Simultaneous use of different context menu in rows and headers
Real time scrolling
Only one assembly Dapfor.Net.dll is required for application deployment
Creation of a single executable with ILMerge utility
Since Dapfor.Net.dll contains minimum number of images, size of this library doesn’t exceed 1 MB.
Deployment to unlimited number of end computers without any fees
Dapfor.Net.dll can be used as a component of other library that can be used by other developers.
Integrated debugging tools for run-time application debugging, also without Visual Studio
- High insertion rate: > 100 000 rows/second.
- High removal rate: > 600 000 rows/second.
- High grouping rate: > 60 000 rows/second.
- High real-time regrouping rate: > 10 000 rows in a grid of 5 000 rows per second.
- High real-time filtering rate: > 7 000 rows in a grid of 5 000 rows per second.
- Productive sorting algorithms: > 5 000 sorts in a grid of 5 000 rows per second.
- High updating speed with highlighting > 50 000 cells/second in a grid of 5 000 rows.
- Low memory consumption: The grid of 100 000 rows will consume < 16 MB.
- Practical recommendations to improve performance
- 400+ NUnit tests covering all major features of the .Net Grid
- Coverage of code with tests: various algorithms (sorting, grouping, etc) > 65%, data level > 65%, threading > 80%
- QA team works on the .Net Grid quality
- Bugs discovered by QA team or by our clients are systematically covered by new NUnit tests.
- Diagnostic tools are available not just to our team - programmers can use them in development of their applications.