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.
ReflectiveFilter rFilter = new
ReflectiveFilter(typeof(CompanyName.DomainObjects.ConstrainedType.NameIdReference),
typeof(CompanyName.DomainObjects.ConstrainedType.NameIdReferenceCollection),
FilterClause.Equals, FilterOperand.Or);
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.
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.