動態遞歸拉姆達表達式

Question

我想創建動態拉姆達表達式，以便我可以使用一組過濾參數來過濾列表。這是我到目前爲止有：

的表達式使用內置的方法波紋管，其中T是列表的對象類型

public static Expression<Func<T, bool>> GetExpression<T>(IList<DynamicFilter> filters) 
    { 
     if (filters.Count == 0) 
      return null; 

     ParameterExpression param = Expression.Parameter(typeof(T), "t"); 
     Expression exp = null; 

     if (filters.Count == 1) 
      exp = GetExpression<T>(param, filters[0]); 

     [...] 

     return Expression.Lambda<Func<T, bool>>(exp, param); 
    } 

    private static Expression GetExpression<T>(ParameterExpression param, DynamicFilter filter) 
    { 
     MemberExpression member = Expression.Property(param, filter.PropertyName); 
     ConstantExpression constant = Expression.Constant(filter.Value); 

     [...] 

     return Expression.Call(member, filterMethod, constant); 
    } 

我再打電話

List<Example> list = ...; 
var deleg = ExpressionBuilder.GetExpression<Example>(dynFiltersList).Compile(); 
list = list.Where(deleg).ToList(); 

這個工程只是正如所期望的那樣，只包含簡單類型的對象，但如果內部存在複雜類型，代碼將不再工作。例如，假設我在Example類中有一個自定義類型Field的成員，並且Field有一個字符串屬性Value。如果filter.PropertyName是'Field0'（字段類型），代碼將工作得很好，但如果我有'Field0.Value'，我會得到一個明顯的錯誤，指出在類Example中沒有名爲'Field0.Value'的屬性。

我試圖修改表達構建方法，像這樣：

 MemberExpression member = null; 
     if (filter.PropertyName.Contains('.')) 
     { 
      string[] props = filter.PropertyName.Split('.'); 

      ParameterExpression param1 = Expression.Parameter(typeof(T).GetProperty(props[0]).PropertyType, "t1"); 
      member = Expression.Property(param1, props[0]); 
     } 
     else 
     { 
      member = Expression.Property(param, filter.PropertyName); 
     } 

但後來我在編譯時表達了一個Lambda parameter not in scope錯誤。我有點理解爲什麼我得到這個錯誤，但我不知道如何使這項工作。

底線是我需要使表達式構建方法在形成MemberExpression時遞歸地工作。我最終需要獲得一個list = list.Where(deleg).ToList();，這意味着像這樣的list = list.Where(obj => obj.Field0.Value == 'something').ToList();

我剛開始使用表達式，所以我真的不知道在這方面太多，但任何幫助將不勝感激。

感謝

Answer 1

我意識到這是一個相當古老的職位，但我有相同的問題，在Mark Gravell發佈的回答中發現了一些接近的東西here。我只是修改了它稍微滿足我的需求及以下結果：

private Expression GetDeepProperty(Expression parameter, string property) 
    { 
     var props = property.Split('.'); 
     var type = parameter.Type; 

     var expr = parameter; 
     foreach (var prop in props) 
     { 
      var pi = type.GetProperty(prop); 
      expr = Expression.Property(expr, pi); 
      type = pi.PropertyType; 
     } 

     return expr; 
    } 

實現：

var method = typeof (string).GetMethod("Contains", new Type[] {typeof (string)}, null); 
var lambdaParameter = Expression.Parameter(typeof(TEntity), "te"); 
var filterExpression = Expression.Lambda<Func<TEntity, bool>> (
      filters.Select(filter => Expression.Call(GetDeepProperty(lambdaParameter, filter.Property), 
                 method, 
                 Expression.Constant(filter.Value))). 
       Where(exp => exp != null). 
       Cast<Expression>(). 
       ToList(). 
       Aggregate(Expression.Or), lambdaParameter); 

Answer 2

看一看ExpressionVisitor如下所述：Replacing the parameter name in the Body of an Expression

Answer 3

我試圖解決

，這樣我可以過濾使用一組過濾參數列表

不是使用ExpressionBuilder而是使用通用的Filter類。

public class Filter<T> where T: class 
{ 
    private readonly Predicate<T> criteria; 

    public Filter(Predicate<T> criteria) 
    { 
     this.criteria = criteria; 
    } 

    public bool IsSatisfied(T obj) 
    { 
     return criteria(obj); 
    } 
} 

首先我們需要有一些類。

public class Player 
{ 
    public string Name { get; set; } 
    public int Level { get; set; } 
    public enum Sex { Male, Female, Other }; 
    public Weapon Weapon { get; set; } 
} 

public class Weapon 
{ 
    public string Name { get; set; } 
    public int MaxDamage { get; set; } 
    public int Range { get; set; } 
    public WeaponClass Class { get; set; } 

    public enum WeaponClass { Sword, Club, Bow } 
} 

然後我們需要一個對象列表。

var graywand = new Weapon { Name = "Graywand", MaxDamage = 42, Range = 1, Class = Weapon.WeaponClass.Sword }; 
var scalpel = new Weapon { Name = "Scalpel", MaxDamage = 33, Range = 1, Class = Weapon.WeaponClass.Sword }; 
var players = new List<Player> { 
    new Player { Name = "Fafhrd", Level = 19, Weapon = graywand }, 
    new Player { Name = "Gray Mouser", Level = 19, Weapon = scalpel }, 
    new Player { Name = "Freddy", Level = 9, Weapon = graywand }, 
    new Player { Name = "Mouse", Level = 8, Weapon = scalpel} 
}; 

然後讓我們創建幾個過濾器並將它們添加到列表中。

var powerfulSwords = new Filter<Player>(p => p.Weapon.MaxDamage>35); 
var highLevels = new Filter<Player>(p => p.Level>15); 

var filters = new List<Filter<Player>>(); 
filters.Add(powerfulSwords); 
filters.Add(highLevels); 

最後通過這些過濾器過濾列表

var highLevelAndPowerfulSwords = players.Where(p => filters.All(filter => filter.IsSatisfied(p))); 
var highLevelOrPowerfulSwords = players.Where(p => filters.Any(filter => filter.IsSatisfied(p))); 

只有「Fafhrd」將在highLevelAndPowerfulSwords和highLevelOrPowerfulSwords將包含所有的球員，但「鼠標」。

Answer 4

您可以生成過濾器的每個元素的表達，使用下面的方法將它們合併成一個單一的表達：

public static Expression<Func<T, K>> CombineAnd<T, K>(Expression<Func<T, K>> a, Expression<Func<T, K>> b) 
    { 
     ParameterExpression firstParameter = a.Parameters.First(); 
     Expression<Func<T, K>> b1 = Expression.Lambda<Func<T, K>>(Expression.Invoke(b, firstParameter), firstParameter); 
     return Expression.Lambda<Func<T, K>>(Expression.And(a.Body, b1.Body), firstParameter); 
    } 
    public static Expression<Func<T, K>> CombineOr<T, K>(Expression<Func<T, K>> a, Expression<Func<T, K>> b) 
    { 
     ParameterExpression firstParameter = a.Parameters.First(); 
     Expression<Func<T, K>> b1 = Expression.Lambda<Func<T, K>>(Expression.Invoke(b, firstParameter), firstParameter); 
     return Expression.Lambda<Func<T, K>>(Expression.Or(a.Body, b1.Body), firstParameter); 
    }