Filtering object collections using reflection

• Download source with demo - 11.6 Kb

Introduction

We all know that when writing software, re-use is of importance to get the most out of the time we have. When we apply this to object collections, we should be aiming to write collection agnostic code that can be used over and over again. For example, when we use a collection of say User objects, we should be able to give it the same operation as we give a collection of Car objects. The operation that we pass to the collection shouldn't care if the collection has cars, users or elephants. It just knows how to perform its operation.

Background

I stumbled on a great article recently on sorting object collections using reflection. The PropertySorter would be passed to the sort method of any strongly typed collection and would sort it depending on the values passed. Doing the same thing with filtering was therefore my aim: to be able to have a strongly typed collection that would implement an IFilterable interface and take in a ReflectiveFilter.

Reflective Filter Features

The features of the ReflectiveFilter are as follows:

• Use the FilterOperand to decide if you want to place And or Or between the FilterProperties.
• Use the FilterClause to decide if you want to place a Equals or IsNotEqualTo in the filter criteria.
• Add as many filters as you like using the AddFilter method of the ReflectiveFilter.

Using the code

To use the ReflectiveFilter is easy. Simply instantiate a new instance of the filter, add the filters you need, and the Filter method will pass back a strongly typed collection that is filtered on your requirements.

Example: We have a collection of names and IDs and want to filter it so we only get back names that are equal to Phil or Richard.

// In the reflective filter, we pass it (at the least)

// the typeof object that is contained in the collection we are filtering

// We also pass in the type of collection we arefiltering (and expect back)


ReflectiveFilter rFilter = new 
 ReflectiveFilter(typeof(CompanyName.DomainObjects.ConstrainedType.NameIdReference),
 typeof(CompanyName.DomainObjects.ConstrainedType.NameIdReferenceCollection), 
 FilterClause.Equals, FilterOperand.Or);
// add  filters 

// as above we have used the OR operator and the Equals clause

// this means we will get all records where

// the name=Richard OR name=Phil

rFilter.AddFilter("Name", "Richard");
rFilter.AddFilter("Name", "Phil");

ACollectionType filteredCollection = new NameIdReferenceCollection();
filteredCollection = nameIdReferenceCollection.Filter(rFilter);

As you can see from the example, we pass in up to four parameters.

• The type of object contained in the collection you are filtering (required).
• The type of collection being filtered (required).
• The FilterClause (optional / defaults to FilterClause.Equals).
• The FilterOperand (optional / defaults to FilterOperand.Or).

The FilterClause can be set to either Equals or IsNotEqualTo and defaults to Equals.

The FilterOperand can be set to either Or or And, and defaults to Or. The job of the FilterOperand is when we have more than one filter applied, to either specify that we need to look for (for example) records where Parameter=Value Or/And Parameter=Value.

The default constructor accepts just two parameters:

• The typeOfObject: The type of object that is contained in the collection we are filtering.
• The typeOfCollection: The type of collection that is being filtered.

Conclusion

The ReflectiveFilter seems to perform quickly and because it is collection agnostic, means that most other requirements for custom filters are not needed.