Runtime Configuration of Where Condition LINQ for Objects

• Download source - 3.6 KB

Update April 2015

There's a much better solution to the problem of flexible where conditions in LINQ queries than the one outlined in this article. Have a look here:

• http://www.codeproject.com/Articles/895951/Combining-expressions-to-dynamically-append-criter

Introduction

A problem I've encountered when using LINQ for Objects is creating queries that can deal easily with varying numbers of parameters obtained from a search dialogue. This short article outlines a partial solution to the problem.

Background

The solution is based on the simple replacement of a hard coded condition with a function. A basic LINQ query looks much as below:

var query = from TestClass t in TestData
where t.Alpha == 10
select {t.Name}

This is ideal if all you want to do is test the Alpha property of TestClass objects. We can get a bit more flexibility using one or more Lambda functions and referencing the function that meets our needs.

Func<TestClass, bool> filter = delegate(TestClass t)
                                     { return (t.Alpha >= 10 && t.Gamma >300); };

var query = from TestClass t in TestData
where (filter)
select {t.Name};

However, each function we define still hard codes the name and number of properties tested. This is not what I wanted.

Using the Code

There are only three classes.

Class: [Condition]

Allows the programmer to group together a number of property tests either as an AND group or as an OR group. This collection of tests can be added to or completely re-initialised without affecting the LINQ query. The query can be re-run with different configurations of the Condition objects that were referenced in the query's definition.

Evaluate<T> (T Instance)

Evaluate<T> (T Instance, TestLogic)

Class: [Condition.Test]

This allows the programmer to associate a property name with a test appropriate to the property's type and a value to test against.

Class: [Comparison]

Uses reflection and some simple switch{} statements to carry out a test defined by a Condition.Test or an instance of an object.

Test<T>
			(T Instance,
			string propertyName,
			Comparison.Text comparison,
			string compareTo)

Test<T>
			(T Instance,
			string propertyName,
			Comparison.Number comparison,
			object compareTo)

Setting up a Condition

Although the example has the property names and test values hard coded, I hope it is apparent that the tests added to each condition can be defined in response to user input taken from a search dialogue or the result of some other change in program state.

Tests can either be applied as an OR group or as an AND group. If not specified, the default behaviour is AND.

// Create a condition containing multiple tests that apply to an object
// of type TestClass
// Tests within the condition will be applied using logical OR.
Condition<TestClass> whereCondition = new Condition<TestClass>() {Logic = TestLogic.Or} ;

whereCondition.Tests.Add(new Condition<TestClass>.Test() {PropertyName="Alpha",
                                                       Compare = Comparison.Number.GreaterEqual,
                                                       CompareTo = 10});
whereCondition.Tests.Add(new Condition<TestClass>.Test() {PropertyName="Gamma",
                                                       Compare = Comparison.Number.Greater,
                                                       CompareTo = 300});
whereCondition.Tests.Add(new Condition<TestClass>.Test() {PropertyName="Name",
                                                       Compare = Comparison.Text.Contains,
                                                       CompareTo = "D"});

Define the Query...

var query = from TestClass t in TestClass.testdata()
where (whereCondition.Evaluate<TestClass>(t))
select new {t.Name};

...and Run It

// Run the query with the where Condition in its initial state.
foreach (var t in query)
Console.WriteLine(t.Name);

Having separated the where logic setup from the query definition, we can now re-run the query as many times as we like altering the where condition as the fancy takes us...

Swapping to logical AND...

whereCondition.Logic = TestLogic.And;
foreach (var t in query)
  Console.WriteLine(t.Name);

Completely Changing the Condition...

whereCondition.Tests.Clear();
whereCondition.Logic = TestLogic.Or;
whereCondition.Tests.Add(new Condition<TestClass>.Test() {PropertyName="Alpha",
                                                       Compare = Comparison.Number.GreaterEqual,
                                                       CompareTo = 100});
whereCondition.Tests.Add(new Condition<TestClass>.Test() {PropertyName="Beta",
                                                       Compare = Comparison.Number.LessEqual,
                                                       CompareTo = 20});

foreach (var t in query)
  Console.WriteLine(t.Name);

Or have no tests at all...

whereCondition.Tests.Clear();

foreach (var t in query)
  Console.WriteLine(t.Name);

Combining Multiple Conditions

// Set up  (t.Alpha >= 100 || t.Beta <= 20) && t.Gamma >= 30

whereCondition.Logic = TestLogic.Or;
whereCondition.Tests.Add(new Condition<TestClass>.Test() {PropertyName="Alpha",
                                                       Compare = Comparison.Number.GreaterEqual,
                                                       CompareTo = 100});
whereCondition.Tests.Add(new Condition<TestClass>.Test() {PropertyName="Beta",
                                                       Compare = Comparison.Number.LessEqual,
                                                       CompareTo = 20});

// ..define an additional condition.
Condition<TestClass> supplementary = new Condition<TestClass>();
supplementary.Tests.Add(new Condition<TestClass>.Test() {PropertyName="Gamma",
                                                       Compare = Comparison.Number.GreaterEqual,
                                                       CompareTo = 30});


// ...and redefine the query to use both conditions.

query = from TestClass t in TestClass.testdata()
      where (whereCondition.Evaluate<TestClass>(t) &&
             supplementary.Evaluate<TestClass>(t))
      select new {t.Name};

foreach (var t in query)
  Console.WriteLine(t.Name);

Pros & Cons

Pros

• Where condition definition independent of query definition
• We open up the possibility of persisting and retrieving where condition definitions

Cons

• Quite a bit more typing required to set up where conditions.
• As written only suitable for properties representing string or numeric types. Date comparisons might be nice.
• Code not so transparent and therefore may be more difficult to maintain.
• There _must_ be a performance penalty.
• There's probably a more elegant solution out there, I just haven't come across it. Yet.

History

• February 2012 - First (and probably final) cut