Features
Initially the grid was designed for the electronic markets with their stringent requirements to be robust, consume little memory and CPU resources, have an ergonomic user interface and easy, but rich API. These requirements have a single target: to be the first on the market, gain the development time and to be productive at run-time. As a result, we present the most productive and robust hierarchical grid with one of the best object models. This component can be used in many types of (not only in electronic markets) applications. This will make the programs more user-friendly, reduce CPU and memory consumption and considerably accelerate development time thanks to multiple services included in the grid and RAD (rapid application development) patterns.
.Net technology
- CLR 2.0 and higher
- Written entirely in managed C#
- Comprehensive documentation with many samples, integrated into Visual Studio
- Design time integration
- Low consumption of CPU and memory resources
Data types
The grid separates business data from the presentation, which has obvious advantages:
- User-defined objects, IEnumerable, IList, IList<>, IDictionary, object[] ...
- The data types listed above can be added individually, not only from IList or IListSource interfaces.
- The data can be added on any hierarchical level.
- Advanced data binding to user-defined objects. Listening to notifications from INotifyPropertyChanged interface, resolving threading issues. Automatic refresh, sorting, filtering and highlighting updating data. Hierarchical data binding.
- Automatic data exchange between editors and user-defined objects.
Data separation from its presentation
- This architecture can build applications in which the business logic does not depend on the GUI and graphical controls.
- The presentation is always synchronized with data. You can modify the business data without knowing where and how it is presented.
- The same data may be shared between many grids or various rows in the same grid – there are no copies of business data.
- The data is correctly sorted. For example, a date is stored as DateTime, but may be shown as ‘24/01/2010’ or ‘01/24/2010’ (US format). To sort the rows, the grid compares DateTime objects, not strings, and independently of the culture. The rows are well sorted.
- Low memory consumption: The data is stored as non-formatted values such as int, double, DateTime… and not as formatted strings such as ‘24/01/2010’. Non formatted data requires much less memory than strings.
- Low CPU consumption: comparing two integer values is less expensive than comparing two strings.
Threadsafety features:
- .Net Grid is safe while adding, removing and updating data.
- .Net Grid can be safely notified about business data updating. Then, the grid will automatically repaint, sort, filter and highlight affected rows and cells.
When a control is bound to the business logic, it may be notified about data updating from the non-GUI thread. Without synchronization with the calling thread, the application would crash. The synchronization can be complicated due to the need for the business logic to call the Control.Invoke/Control.BeginInvoke methods which break the application architecture. This makes the separation of the business logic and its presentation practically impossible. The .Net Grid performs the synchronization itself and can be notified through the INotifyPropertyChanged interface from any thread.
Major features
- Multiple headers mode
- Tree list view mode with a single header
- Any hierarchy can easily be built
- Fixed and scrollable columns
- Various types of data: user-defined objects, IEnumerable, IList, IList<>, IDictionary, object[]
- Separation of business logic data from the presentation
- Sharing the same data between many rows and grids
- Advanced data formatting and parsing
- Support for standard edit controls (Font dialog, Color selector, docking controls...) as well as custom controls
- Advanced editors, one can edit values directly in cells (not only as drop-down controls or modal Forms).
- Accurate and precise behavior on the user’s input
- Full drawing customization without inheriting from the .Net Grid
- Real-time scrolling
- Transparent selection
- Ultimate performance and low memory and CPU consumption
- Real-time sorting, filtering, grouping and highlighting
- Net Grid is a thread-safe component: the business data can be added and can notify the grid from any thread. No deadlock issues thanks to asynchronous data updating architecture.
- Optimized to handle a large volumes of data updated in real-time.
Automatic services
- Automatic refresh of cells, when the business data is changed without using the Dapfor’s API.
- Automatic sort of rows, when the business data is modified, even in the hierarchical .Net Grid.
- Automatic filtering of updated data.
- Automatic group updating when the data is changed.
- Automatic highlighting of updating cells for a specific duration. Various highlighting settings are available.
The automatic services will make the programming easier and more robust. There is no need to implement huge procedures of sorting or filtering. The .Net Grid implements everything you were doing manually before. The .Net Grid supports the data separation from the presentation and the business level may notify the grid though the INotifyPropertyChanged interface. This will permit you to remove all dependencies from the Dapfor’s components. For instance, the assemblies with the business data need not have references to the .Net Grid’s assembly.
Performance
The .Net Grid is optimized to work with a great volume of information, updating it all in real-time.
- High insertion speed: > 100 000 rows/second.
- Productive sort algorithms: > 3000 sorts in a grid of 2000 rows per second.
- High updating speed with highlighting > 50 000 cells/second.
- Low memory consumption: A grid of 100 000 rows will consume < 16 Mb.