轉換包含表達式樹

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); 
    } 
}