The following bug has been fixed:

• [BUG] Fixed a bug where the grid redraw the content of the entire row upon receiving notification from INotifyPropertyChanged interface for missing or hidden column.
• [BUG] Fixed minor bugs in the designer.

The following features have been added:

• [NEW] Added column filter serialization
• [NEW] Reengineered grid designer introducing intuitive and convenient user interface.
• [NEW] Significantly improved grid performance with selection large data volumes.
• [NEW] Overall performance improvement.

The following bugs have been fixed:

• [BUG] Fixed an error with the grid not unsubscribing from objects with composite properties when objects are removed from the grid.
• [BUG] Fixed an error with Dapfor.Net.dll not appearing in the list of available assemblies in Visual Studio.
• [BUG] Fixed an error with Column.Appearance property hiding cell highlighting.
• Minor bug fixes

.Net Suite, v2.7.0 (Build 2.7.0.46034) [2012-02-20]

Starting from version 2.7.0 grid functionality has been expanded with reporting and printing features. Programmers get simple and convenient interface for implementing new features and can significantly expand capabilities of target applications.

Reporting features:

• 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

The following bug has been fixed:

• [BUG] .Net Grid wrongly filters the content if two filters (Grid.Filter and Column.Filter) are set simultaneously.

Professionals working with complex systems will surely appreciate our efforts that make the code simpler and improve its reliability. Let’s create the best applications together!

In our opinion, IBindingList should not contain hierarchy information. It is possible to use multiple binding lists to build it. For example, let’s take Strategy class that may contain multiple orders that can be dynamically added to this class or removed from it.

class Order
{
   ...
}

public class Strategy
{
    private readonly BindingList<Order> _orders = new BindingList<Order&gt();

    public IList<Order> Orders
    {
        get { return _orders; }
    }
}

//Add a new order to a strategy:
Order order = ...;
strategy.Orders.Add(order);

//Add a strategy to a grid
Strategy strategy = ...
grid.Rows.Add(strategy);

Let’s note that when a strategy is added to the grid, it cannot display orders as it doesn’t have hierarchy information. It is possible to use declarative binding to tell the grid that Strategy.Orders field should be viewed as hierarchy foundation.

public class Strategy
{
    [HierarchicalField]
    public IList<Order> Orders
    {
        ...
    }
}

When a strategy is added to the grid, it automatically subscribes to binding list returned by this strategy. It enables to use full-featured hierarchical binding with dynamic hierarchy modification without direct access to data presentation layer. To ensure complete separation of presentation layer from data layer we shall place strategy objects to IBindingList:

BindingList<Strategy> strategies = new BindingList<Strategy>();
//Populate collection with strategies
...

//Bind collection to the grid
grid.DataSource = strategies;

----- Strategies and orders will be presented in .Net Grid as following ---------------
+ Strategy
 |- Order
 |- Order
 | ...
+ Strategy
 |- Order
 |- Order
 | ...

Conclusion:
In our example we have achieved full separation of data from presentation. Data manipulation doesn’t require access to control, and this is true for hierarchical declarative data binding as well. Let’s also note that displayed data can be grouped, sorted and filtered without additional effort of the programmer.

In our opinion, the above hierarchy building method is one of the most efficient methods provided by the grid. Besides declarative binding, it is possible to build a hierarchy by simply adding data objects to any row. It is also possible to use conditional binding and binding on any hierarchy level.

Programmers working with actual applications know how much code is required to complete a seemingly simple task of representing hierarchy data in the grid and synchronize it with grid presentation (adding and removing rows, etc). They will definitely appreciate our efforts in this field.

For more information of declarative data binding click here.