Lambda和使用反射来得到的属性名称

Question

比方说，你有一个通用类，它有一个List<T> Items;

现在想这个基本lambda表达式：

var result = Items.FindAll(x => x.Name = "Filip");

这不仅会只要我们知道T的属性，就不会在通用类型的情况下工作。

所以我想使用反射像这样获取的属性：

PropertyInfo[] properties = typeof(T).GetProperties(BindingFlags.Public);

并以某种方式c​​ombind与上述λ-表达式，它会搜索所有类型的公共属性，看看是否它包含“Filip”，此时我不在乎属性名称是否为Name。

这可能吗？

Answer 1

var result = Items.FindAll(x => 
    properties.Any(p => p.PropertyType == typeof(string) && 
         p.GetValue(x, null) == "Filip")); 

显然，这是一个简单的，乐观的字符串比较（你可能想使用string.Compare，例如），但是这应该使思想清晰。

编辑

DTB使得在使用表达式目录树一个很好的建议。你可以做到你以后更快的方式是这样的：

public static class PropertyScanner 
{ 
    static Func<TType, bool> CreatePredicate<TType, TValue>(TValue value, IEqualityComparer<TValue> comparer) 
    { 
     var arg = Expression.Parameter(typeof(TType), "arg"); 

     Expression body = null; 

     Expression<Func<TValue, TValue, bool>> compare = (val1, val2) => comparer.Equals(val1, val2); 

     foreach (PropertyInfo property in typeof(TType).GetProperties(BindingFlags.Public)) 
     { 
      if (property.PropertyType == typeof(TValue) || typeof(TValue).IsAssignableFrom(property.PropertyType)) 
      { 
       Expression prop = Expression.Equal(Expression.Invoke(compare, new Expression[] 
             { 
              Expression.Constant(value), 
              Expression.Property(arg, property.Name) 
             }), 
               Expression.Constant(0)); 

       if (body == null) 
       { 
        body = prop; 
       } 
       else 
       { 
        body = Expression.OrElse(body, prop); 
       } 
      } 
     } 

     return Expression.Lambda<Func<TType, bool>>(body, arg).Compile(); 
    } 

    public static IEnumerable<TType> ScanProperties<TType, TValue>(this IEnumerable<TType> source, TValue value) 
    { 
     return ScanProperties<TType, TValue>(source, value, EqualityComparer<TValue>.Default); 
    } 

    public static IEnumerable<TType> ScanProperties<TType, TValue>(this IEnumerable<TType> source, TValue value, IEqualityComparer<TValue> comparer) 
    { 
     return source.Where(CreatePredicate<TType, TValue>(value, comparer)); 
    } 
} 

这将允许你做这样的事情：

var result = Items.ScanProperties("Filip").ToList(); 

Answer 2

您可以使用表达式树来构建一个lambda导通飞行：

Func<T, bool> CreatePredicate<T>() 
{ 
    var arg = Expression.Parameter(typeof(T), "arg"); 
    var body = Expression.Equal(Expression.Property(arg, "Name"), 
           Expression.Constant("Filip")); 
    return Expression.Lambda<Func<T, bool>>(body, arg).Compile(); 
} 

IEnumerable<T> GetTWhereNameIsFilip<T>(IEnumerable<T> source) 
{ 
    Func<T, bool> predicate = CreatePredicate<T>(); 
    // cache predicate for max performance 

    return source.Where(predicate); 
}