The problem is that building such a composite , domain friendly , expression tree can add really a lot of classes to the application (Specifications Hirarchy, Expression Builders for having Fluent Interfaces,… etc) .

Those who have been arround microsoft technologies lately, might heard about  Linq and C# 3.0, read some articles about it. Unfortunaitly Linq is often missunderstood, as embedding Sql in the code, which is DEFINITLY NOT THE CASE, Linq is all based on expression trees, that are intrepreted by an implementation engine for producing the appropriate query.

I will not go in details into Linq’s use for data quering, but i ll try to demonstrate another use of linq’s expression trees, in making explecit, predicate-like simple composite specifications.

For the purpose of the demo, i ll make a small introduction of some C# 3.0 features i am using.

Extension Methods: Extension Methods are a  syntaxic sugar, representing a special case of static methods to turn it more discoverable .

Example:

public static class Extensions
{    public static bool IsNullOrEmpty(this string s)
    {
        return (s == null || s.Trim().Length == 0 );
    }
}

class Program
{
    static void Main( string[] args)
    {
        string newString = null;
        if (newString.IsNullOrEmpty())
        {
            // Do Something
        }
    }

}

so the “this” keyword in the parameters tells that this will be an extension method for all the object of this type. dont worry , no encapsulation is violated, extension methods have access only to public members.

Lambda Expressions: Lambda expression is a syntaxic sugar of the anonymous methods, for people that dont know delegates, delegates are method holders, u define a type of delegate by specifieng parameters and return types

like

delegate object DelegateName(object par1,objaect par2);

then you can anonymously make a delegate like so

DelegateName myDelegate= delegate(object par1,object par2){

    //do something here and return the delegates return type (object)

    return new object();

};

now u can call this delegate using its name mydelegate(obj1,obj2);

lambda expressions add even shorter syntax for defining the body of the anonymous method so u can for instance write

DelegateName myDelegate= (object par1,object par2)  =>  new object();

after this very brief introduction, i ll start implementing my very simple example of predicates:

first of all i ll define a delegate that will take a type T and returns a bool

delegate bool ObjectPredicateDelegate<T>(T arg);

now i can write

ObjectPredicateDelegate<Student> studentOver18= Student s => s.Age > 18 ;

that defines an anonymous method that is compiled on compile time, so it can be executed using the name “studentOver18″ and passing a student as a prameter, what i want is not method but an expression, lucky enough, Linq namespace has the Expression type so i can right

Expression<ObjectPredicateDelegate<Student>> studentOver18Expression = Student s => s.Age > 18 ;

you should be wondering what the deffirence is, this Epression is not compiled, it is deferred till the runtime, so id i want to execute it i should do

studentOver18Expression.Compile().Invoke(s);

moreover studentOver18Expression.ToString()  will produce “s => s.Age >18″ cool isnt it?

now, i want to implement And and Or operations that produce the same delegate , where i can pass a student and get a boolean. These operations are already implemented by default in Linq namespace, but they return a BooleanExpression which is not really what i want, so i ll do mine using Extension methods

public static Expression<ObjectPredicateDelegate<Student>> And(this Expression<ObjectPredicateDelegate<Student>> exp1, Expression<ObjectPredicateDelegate<Student>> exp2){

             ParameterExpression p = Expression.Parameter(exp1.Parameters[0].Type, exp1.Parameters[0].Name);
             return (Expression<ObjectPredicateDelegate<Student>>)Expression.Lambda<ObjectPredicateDelegate<Student>>(
                Expression.And(Expression.Invoke(exp1,p), Expression.Invoke(exp2,p)), p);

}

now using this extension method i can write

Expression<ObjectPredicateDelegate<Student>> studentOver18Specification = Student s => s.Age > 18 ;

Expression<ObjectPredicateDelegate<Student>> studentUnder26Specification = Student s => s.Age < 26 ;

Expression<ObjectPredicateDelegate<Student>> studentYouthAgeSpecification = studentOver18Specification.And(studentUnder26Specification);

now we can continue implementing other operations like Or, Not… in the same manner.

I agree that ObjectPredicateDelegate<Student> is long to write each time , but we can use the “using” keyword to creat an alias

using StudentPredicateDelegate=ObjectPredicateDelegate<Student>

or even

using StudentPredicate=Expression<ObjectPredicateDelegate<Student>>

this way i can simplify the last code to look more friendly

StudentPredicate studentOver18Specification = Student s => s.Age > 18 ;

StudentPredicate studentUnder26Specification = Student s => s.Age < 26 ;

StudentPredicate studentYouthAgeSpecification = studentOver18Specification.And(studentUnder26Specification);

now studentYouthAgeSpecification.ToString()  will produce     “s => (Invoke(s => (s.age > 18),s) And Invoke(s => (s.age < 26),s))”

i am not sure i ve been very clear, i ll try to post more examples soon :)

Download Sample Code Solution