.Net Grid features
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. .Net technology:
Data types (read more...)
- 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
Data Binding (read more...)
- 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
Event-driven model (read more...)
- 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
Data filtering (read more...)
- 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.
Data grouping (read more...)
- 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.
Data sorting (read more...)
- 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.
Data highlighting (read more...)
- Simple sorting interface
- Sorting objects of different types
- Multiple sorting
- 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.
Headers and columns (read more...)
- 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
Data editing (read more...)
- 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
Customization and appearance (read more...)
- 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
Selection and navigation
- 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
Drag & Drop (read more...)
- 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()
Serialization (read more...)
- 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.
Reporting (read more...)
- 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
Thread safety (read more...)
- 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
Other grid featuresDeployment (read more...)
- 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
Performance (read more...)
- 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
Quality assurance (read more...)
- 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.