Implementing a strongly typed collection with sort/filter/GetChanges features

• Download demo project - 14.6 Kb

Introduction

In my first steps with .NET, I was impressed by the dataset features. Data access was very simple to use/ to bind on Windows forms components such as DataGrid or ComboBox. But with datasets we are far from OOP. We are always working with Tables (DataTable), rows and columns. So when I began to create my own business objects, all became so difficult: data access problems, binding problems and collection problems. I needed a collection of each business objects that presents the DataSet/DataView features (Sorting, Filtering and the DataSet's GetChanges feature) and it must not be a dataset.

I found many discussion about Collection / Strongly Typed Collections but no one presents all features I needed. So I decided to develop my own custom collection that implements the needed interfaces and functions to be simple to use with Windows forms and also in data access.

Features

• DataBinding

  The custom collection inherits from CollectionBase abstract class and implements IBindingList interface and can be bound on all controls of Windows forms (datagrid, combo, list,...).

• Sorting

  The sorting feature is implemented in the IBindingList Interface. So you can sort a column in a DataGrid by clicking on the header of the column.

  Sorting is accessible with a Sort method that accepts a string as parameter ( like the property of the DataView).

• Filtering

  Dataview presents an very useful feature specially when bound to a DataGrid: Filtering. The custom collection offers too the same feature via the ItemFilter property (RowFilter in the DataView). You can set to the ItemFilter property a string like "Name = Test" or "BirthDate > 01/01/1980" and the collection is updated to display only items that respond to the criteria.

• GetChanges feature

  The custom collection is based on an abstract object called BaseObject which have a property called ObjectState that can be UnChanged, Added, Deleted or Changed. So any action you do on the collection is stored and you can have the 'List of Changes" made by the user on the collection of items.

  So any business object you need to implement in a collection must inherit from BaseObject.

Implementation

To create your own custom collection, you need a business object that inherits from BaseObject class. For example, if you create a customer class which present a Name property, this code is needed :

public class Customer : BaseObject
    public Customer()
    {
        //

        // TODO: Add constructor logic here

        //

    }
    private string TmpName;
    public string Name
    {
        get{return TmpName;}
        set
        {
            if (base.Compare(TmpName, value) !=0)
            {
                TmpName = value;
                SetDirtyFlag(); // To set the isdirty property of the object to true

            }

    }

Then create the Customers class which inherit from abstract class CustomCollection. Code will be like this:

public class Customers: CustomCollection
{
   public Customers()
   {
       // define the type of the collection items to Customer

       this.ItemType = typeof(Customer); 
   }
   //indexer that overides the default indexer

   public new Customer this[int index]
   {
      get
      {
         return (Customer)(base[index]);
      }
      set
     {
         base[index] = value;
     }
}
// GetChanges Method that overrides the default one 

//to have a Customer Collection in return

    public new Customers GetChanges()
    {
        return (Customers) base.GetChanges();
    }
}

The demo project includes also source code of CustomCollection and BaseObject.

Conclusion

With this CustomCollection, no need to work with DataSets and DataViews. It combines the features of both of these components and we can work with our business objects. So data access can be easier, databinding in Windows forms and web forms is assured and performance is much better than dataset when filling the custom collection from a datareader.