转换包含表达式树

Question

相关：Create a Lambda Expression With 3 conditions

请考虑下面的代码：

from a in myTbl 
where a.Address.Contains(strToCheck) 
select a 

我如何将此转换为表达式树和上面写有表达式代码？ 主要问题是将a.Address.Contains(strToCheck)转换为Expression Tree。

编辑1）地址是string场和strToCheck是string

感谢

Answer 1

a.Address.Contains(strToCheck)代表在呼叫到string.Contains实例方法a.Address例如与strToCheck说法。

建立相应的表达，最简单的方法是使用下面的Expression.Call overload：

public static MethodCallExpression Call(
    Expression instance, 
    string methodName, 
    Type[] typeArguments, 
    params Expression[] arguments 
) 

像这样（使用链接的问题条款）：

var body = Expression.Call(
    Expression.PropertyOrField(param, "Address"), // instance 
    "Contains", // method 
    Type.EmptyTypes, // no generic type arguments 
    Expression.Constant(strToCheck) // argument 
); 

Answer 2

没有指定MYTBL的类型，
所以我创建了只使用一个简单的解决方案对象列表。

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

namespace Test 
{ 
    class Program 
    { 
     static void Main(string[] args) { 
      var adresses = FilterByAddress("Address", new List<Person> { new Person { Address = "Address1" }, new Person { Address = "AAAAAA" } }); 
     } 

     public static IEnumerable<Person> FilterByAddress(string strToCheck, List<Person> list) { 
      var listParam = Expression.Parameter(typeof(IEnumerable<Person>), "list"); 
      Expression<Func<Person, bool>> contains = a => a.Address.Contains(strToCheck); 
      var select = typeof(Enumerable).GetMethods().Single(m => m.Name.Equals("Where") && m.GetParameters()[1].ParameterType.GetGenericArguments().Length == 2); 
      var genericMethod = select.MakeGenericMethod(new[] { typeof(Person) }); 
      var call = Expression.Call(null, genericMethod, new Expression[] { listParam, contains }); 
      var lambda = Expression.Lambda<Func<IEnumerable<Person>, IEnumerable<Person>>>(call, new[] { listParam }); 

      return lambda.Compile().Invoke(list); 
     } 
    } 

    public class Person 
    { 
     public string Address { get; set; } 
    } 
} 

如果要通过谓词使用过滤器可以传递一个Expresssion<Func<Person, bool>>作为参数（一行）

static void Main(string[] args) { 
     var strToCheck = "Address"; 
     var list = new List<Person> { new Person { Address = "Address1" }, new Person { Address = "AAAAAA" } }; 
     var adresses = FilterByAddress(list, p => p.Address.Contains(strToCheck)); 
    } 

    public static IEnumerable<Person> FilterByAddress(List<Person> list, Expression<Func<Person, bool>> predicateEx) { 
     var listParam = Expression.Parameter(typeof(IEnumerable<Person>), "list"); 
     var select = typeof(Enumerable).GetMethods().Single(m => m.Name.Equals("Where") && m.GetParameters()[1].ParameterType.GetGenericArguments().Length == 2); 
     var genericMethod = select.MakeGenericMethod(new[] { typeof(Person) }); 
     var call = Expression.Call(null, genericMethod, new Expression[] { listParam, predicateEx }); 
     var lambda = Expression.Lambda<Func<IEnumerable<Person>, IEnumerable<Person>>>(call, new[] { listParam }); 

     return lambda.Compile().Invoke(list); 
    } 

如果你有一个非常compilicated谓词跨越到多行（一个表达式树可以从一条线拉姆达进行评估），可以使用一个特技构建表达树出谓词的函数功能是这样的：

static void Main(string[] args) { 
     var strToCheck = "Address"; 
     Func<Person, bool> predicate = p => { 
      return p.Address.Contains(strToCheck); 
     }; 

     var list = new List<Person> { new Person { Address = "Address1" }, new Person { Address = "AAAAAA" } }; 
     var adresses = FilterByAddress(list, predicate); 
    } 

    public static IEnumerable<Person> FilterByAddress(List<Person> list, Func<Person, bool> predicate) { 
     var listParam = Expression.Parameter(typeof(IEnumerable<Person>), "list"); 
     Expression<Func<Person, bool>> predicateEx = p => predicate(p); 
     var select = typeof(Enumerable).GetMethods().Single(m => m.Name.Equals("Where") && m.GetParameters()[1].ParameterType.GetGenericArguments().Length == 2); 
     var genericMethod = select.MakeGenericMethod(new[] { typeof(Person) }); 
     var call = Expression.Call(null, genericMethod, new Expression[] { listParam, predicateEx }); 
     var lambda = Expression.Lambda<Func<IEnumerable<Person>, IEnumerable<Person>>>(call, new[] { listParam }); 

     return lambda.Compile().Invoke(list); 
    } 

使用通用的方法，通过谓词来筛选列表

static void Main(string[] args) { 
     var strToCheck = "Address"; 
     Func<Person, bool> predicate = p => { 
      return p.Address.Contains(strToCheck); 
     }; 

     var list = new List<Person> { new Person { Address = "Address1" }, new Person { Address = "AAAAAA" } }; 
     var adresses = FilterBy<Person>(list, predicate); 
    } 

    public static IEnumerable<T> FilterBy<T>(List<T> list, Func<T, bool> predicate) { 
     var listParam = Expression.Parameter(typeof(IEnumerable<T>), "list"); 
     Expression<Func<T, bool>> predicateEx = p => predicate(p); 
     var select = typeof(Enumerable).GetMethods().Single(m => m.Name.Equals("Where") && m.GetParameters()[1].ParameterType.GetGenericArguments().Length == 2); 
     var genericMethod = select.MakeGenericMethod(new[] { typeof(T) }); 
     var call = Expression.Call(null, genericMethod, new Expression[] { listParam, predicateEx }); 
     var lambda = Expression.Lambda<Func<IEnumerable<T>, IEnumerable<T>>>(call, new[] { listParam }); 

     return lambda.Compile().Invoke(list); 
    } 
}