Predicates in Lambda Expression for Entity Framework Code First @ 肖恩D++

Predicates in Lambda Expression for Entity Framework Code First

Posted on July 24th, 2013 Sean 1 comment

If I have 2 entities of “People” and “Car”, and “1” People can have “Many” Car, my code first class could be like below:

public class People
{
	[key]
	public int ID { get; set; }
	public string Name { get; set; }
	
	public virtual ICollection<Car> Cars { get; set; }
}

public class Car
{
	[key]
	public string VIN { get; set; }
	public string Maker { get; set; }
	public int OwnerID { get; set; }
	
	[ForeignKey("OwnerID")]
	public virtual People Owner { get; set; }
}

public class People

{

[key]

public int ID { get; set; }

public string Name { get; set; }

public virtual ICollection<Car> Cars { get; set; }

}

public class Car

{

[key]

public string VIN { get; set; }

public string Maker { get; set; }

public int OwnerID { get; set; }

[ForeignKey("OwnerID")]

public virtual People Owner { get; set; }

}

Let’s say, if we want to find the person who name is “Sean”, and has a car of maker “GMC” by using lambda Predicates, we probably need to do like below:

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Collections.Generic;

...
Entities context = new Entities();//DBContext object
Expression<Func<People, bool>> pLambda = x => x.Name == "Sean";
Expression<Func<Car, bool>> cLambda = x => x.Maker == "GMC";
List<People> result = context.People.Where(pLambda)
	.Where(x => x.Cars.AsQueryable().Any(cLambda)).ToList();

using System;

using System.Linq;

using System.Linq.Expressions;

using System.Collections.Generic;

...

Entities context = new Entities();//DBContext object

Expression<Func<People, bool>> pLambda = x => x.Name == "Sean";

Expression<Func<Car, bool>> cLambda = x => x.Maker == "GMC";

List<People> result = context.People.Where(pLambda)

.Where(x => x.Cars.AsQueryable().Any(cLambda)).ToList();

What if I want to compose above 2 lambda to 1? Unfortunately there is no easy way to simply join multiple lambda by whatever “AND” or “OR”, specially if navigation properties involved like the example above.
From Colin Meek’s Blog, we can manually write a general utility method to compose lambda expressions

public static class Utility {
	public static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge) {
		// build parameter map (from parameters of second to parameters of first)
		var map = first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f);

		// replace parameters in the second lambda expression with parameters from the first
		var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);

		// apply composition of lambda expression bodies to parameters from the first expression 
		return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
	}

	public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) {
		return first.Compose(second, Expression.And);
	}

	public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) {
		return first.Compose(second, Expression.Or);
	}
}

//Important rebinder to merge different parameters from multiple lambda
public class ParameterRebinder : ExpressionVisitor {
    private readonly Dictionary<ParameterExpression, ParameterExpression> map;
 
    public ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map) {
        this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
    }
 
    public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp) {
        return new ParameterRebinder(map).Visit(exp);
    }
 
    protected override Expression VisitParameter(ParameterExpression p) {
        ParameterExpression replacement;
        if (map.TryGetValue(p, out replacement)) {
            p = replacement;
        }
        return base.VisitParameter(p);
    }
}

public static class Utility {

public static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge) {

// build parameter map (from parameters of second to parameters of first)

var map = first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f);

// replace parameters in the second lambda expression with parameters from the first

var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);

// apply composition of lambda expression bodies to parameters from the first expression

return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);

}

public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) {

return first.Compose(second, Expression.And);

}

public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) {

return first.Compose(second, Expression.Or);

}

//Important rebinder to merge different parameters from multiple lambda

public class ParameterRebinder : ExpressionVisitor {

private readonly Dictionary<ParameterExpression, ParameterExpression> map;

public ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map) {

this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();

}

public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp) {

return new ParameterRebinder(map).Visit(exp);

}

protected override Expression VisitParameter(ParameterExpression p) {

ParameterExpression replacement;

if (map.TryGetValue(p, out replacement)) {

p = replacement;

}

return base.VisitParameter(p);

}

By using this utility, we can write our code simply like below

Entities context = new Entities();//DBContext object
Expression<Func<People, bool>> pLambda = x => x.Name == "Sean";
Expression<Func<Car, bool>> cLambda = x => x.Maker == "GMC";
pLambda = pLambda.And(x => x.Cars.AsQueryable().Any(cLambda));
List<People> result = context.People.Where(pLambda).ToList();

Entities context = new Entities();//DBContext object

Expression<Func<People, bool>> pLambda = x => x.Name == "Sean";

Expression<Func<Car, bool>> cLambda = x => x.Maker == "GMC";

pLambda = pLambda.And(x => x.Cars.AsQueryable().Any(cLambda));

List<People> result = context.People.Where(pLambda).ToList();

ASP.NET

(No Ratings Yet)

641 views

1 Comment on "Predicates in Lambda Expression for Entity Framework Code First"

Please insert the code above to comment

Notify of new replies to this comment
Notify of all new follow-up comments

Guest

Clarissa

09/12/2014

I read a lot of interesting posts here. Probably you spend a lot of time writing, i know how to save you a lot of time, there is

an online tool that creates high quality, SEO friendly articles in minutes,

just type in google – laranitas free content source

∧ | ∨ Reply