Last active
January 3, 2016 23:19
-
-
Save Wind4/8534625 to your computer and use it in GitHub Desktop.
PredicateBuilder
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System; | |
using System.Collections.Generic; | |
using System.Linq; | |
namespace System.Linq.Expressions | |
{ | |
public sealed 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); | |
} | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System; | |
using System.Linq; | |
using System.Linq.Expressions; | |
using System.Collections.Generic; | |
public static class PredicateBuilder | |
{ | |
public static Expression<Func<T, bool>> True<T> () { return f => true; } | |
public static Expression<Func<T, bool>> False<T> () { return f => false; } | |
public static Expression<Func<T, bool>> Or<T> (this Expression<Func<T, bool>> expr1, | |
Expression<Func<T, bool>> expr2) | |
{ | |
var invokedExpr = Expression.Invoke (expr2, expr1.Parameters.Cast<Expression> ()); | |
return Expression.Lambda<Func<T, bool>> | |
(Expression.OrElse (expr1.Body, invokedExpr), expr1.Parameters); | |
} | |
public static Expression<Func<T, bool>> And<T> (this Expression<Func<T, bool>> expr1, | |
Expression<Func<T, bool>> expr2) | |
{ | |
var invokedExpr = Expression.Invoke (expr2, expr1.Parameters.Cast<Expression> ()); | |
return Expression.Lambda<Func<T, bool>> | |
(Expression.AndAlso (expr1.Body, invokedExpr), expr1.Parameters); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
using System; | |
using System.Collections.Generic; | |
using System.Linq; | |
namespace System.Linq.Expressions | |
{ | |
public static class PredicateBuilder | |
{ | |
/// <summary> | |
/// Creates a predicate that evaluates to true. | |
/// </summary> | |
public static Expression<Func<T, bool>> True<T>() | |
{ | |
return param => true; | |
} | |
/// <summary> | |
/// Creates a predicate that evaluates to false. | |
/// </summary> | |
public static Expression<Func<T, bool>> False<T>() | |
{ | |
return param => false; | |
} | |
/// <summary> | |
/// Creates a predicate expression from the specified lambda expression. | |
/// </summary> | |
public static Expression<Func<T, bool>> Create<T>(Expression<Func<T, bool>> predicate) | |
{ | |
return predicate; | |
} | |
/// <summary> | |
/// Combines the first predicate with the second using the logical "and". | |
/// </summary> | |
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) | |
{ | |
return first.Compose(second, Expression.AndAlso); | |
} | |
/// <summary> | |
/// Combines the first predicate with the second using the logical "or". | |
/// </summary> | |
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) | |
{ | |
return first.Compose(second, Expression.OrElse); | |
} | |
/// <summary> | |
/// Negates the predicate. | |
/// </summary> | |
public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expression) | |
{ | |
UnaryExpression negated = Expression.Not(expression.Body); | |
return Expression.Lambda<Func<T, bool>>(negated, expression.Parameters); | |
} | |
/// <summary> | |
/// Combines the first expression with the second using the specified merge function. | |
/// </summary> | |
private static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge) | |
{ | |
// zip parameters (map from parameters of second to parameters of first) | |
Dictionary<ParameterExpression, ParameterExpression> 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 the parameters in the first | |
Expression secondBody = ParameterRebinder.ReplaceParameters(map, second.Body); | |
// create a merged lambda expression with parameters from the first expression | |
return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters); | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment