C# 将包含转换为表达式树

有关：

请考虑此代码：

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

如何将其转换为表达式树并使用表达式编写上述代码？ 主要问题是将

a.Address.Contains（strToCheck）

转换为

表达式树

编辑1）地址是一个

字符串

字段，

strotcheck

是一个

字符串

---

谢谢你没有指定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; }
    }
}

使用系统；
使用System.Linq；
使用System.Linq.Expressions；
使用System.Collections.Generic；
名称空间测试
{
班级计划
{
静态void Main（字符串[]参数）{
var Address=FilterByAddress（“地址”，新列表{new Person{Address=“Address1”}，new Person{Address=“AAAAAA”}）；
}
公共静态IEnumerable FilterByAddress（字符串strToCheck，列表）{
var listParam=Expression.Parameter（typeof（IEnumerable），“list”）；
表达式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，新表达式[]{listParam，contains}）；
var lambda=Expression.lambda（调用，new[]{listParam}）；
返回lambda.Compile（）.Invoke（列表）；
}
}
公共阶层人士
{
公共字符串地址{get；set；}
}
}

如果要使用“按谓词筛选”，可以将

expression

作为参数传递（一行）

static void Main（字符串[]args）{
var strToCheck=“地址”；
var list=newlist{newperson{Address=“Address1”}，newperson{Address=“AAAAAA”}；
var Address=FilterByAddress（list，p=>p.Address.Contains（strToCheck））；
}
公共静态IEnumerable FilterByAddress（列表、表达式谓词）{
var listParam=Expression.Parameter（typeof（IEnumerable），“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，新表达式[]{listParam，predicateEx}）；
var lambda=Expression.lambda（调用，new[]{listParam}）；
返回lambda.Compile（）.Invoke（列表）；
}

如果您有一个非常复杂的谓词，它跨越多行（表达式树可以从一行lambda计算），您可以使用以下技巧从谓词Func构造表达式树：

    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（字符串[]args）{
var strToCheck=“地址”；
Func谓词=p=>{
返回p.Address.Contains（strToCheck）；
};
var list=newlist{newperson{Address=“Address1”}，newperson{Address=“AAAAAA”}；
var address=FilterByAddress（列表，谓词）；
}
公共静态IEnumerable FilterByAddress（列表，Func谓词）{
var listParam=Expression.Parameter（typeof（IEnumerable），“list”）；
表达式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，新表达式[]{listParam，predicateEx}）；
var lambda=Expression.lambda（调用，new[]{listParam}）；
返回lambda.Compile（）.Invoke（列表）；
}

使用泛型方法按谓词筛选列表

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

static void Main（字符串[]args）{
var strToCheck=“地址”；
Func谓词=p=>{
返回p.Address.Contains（strToCheck）；
};
var list=newlist{newperson{Address=“Address1”}，newperson{Address=“AAAAAA”}；
var address=FilterBy（列表，谓词）；
}
公共静态IEnumerable筛选器by（列表，Func谓词）{
var listParam=Expression.Parameter（typeof（IEnumerable），“list”）；
表达式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，新表达式[]{listParam，predicateEx}）；
var lambda=Expression.lambda（调用，new[]{listParam}）；
返回lambda.Compile（）.Invoke（列表）；
}
}

您没有指定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; }
    }
}

使用系统；
使用System.Linq；
使用System.Linq.Expressions；
使用System.Collections.Generic；
名称空间测试
{
班级计划
{
静态void Main（字符串[]参数）{
var Address=FilterByAddress（“地址”，新列表{new Person{Address=“Address1”}，new Person{Address=“AAAAAA”}）；
}
公共静态IEnumerable FilterByAddress（字符串strToCheck，列表）{
var listParam=Expression.Parameter（typeof（IEnumerable），“list”）；
表达式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=Expr
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
);