c# - Enumerable.Select 的表达式树

Question

编辑 我想我可以问得更好(在这种情况下根本不需要代码)。所以一般的问题是:如何使用表达式树来构建对通用方法的调用 (Select<TEntity,TResult>在我的例子中)当TResult是在运行时创建的？忽略下面所有的代码和文本，这是问题的不明确版本，让它不混淆那些回答的人。

我需要一个示例，说明如何为“选择”调用构建表达式树。问题是我在编译时不知道结果类型(它可以由用户在运行时通过一些 GUI 定义)。这是我如何尝试执行此操作的一些代码(记住我不能使用任何泛型)

class Pet {
    public int Id { get; set; }
    public string Name { get; set; }
}

在 Main 中使用这个类:

List<Pet> list = new List<Pet>();                
Expression eList = Expression.Constant(list);
ParameterExpression pe = Expression.Parameter(typeof(Pet), "p");
MethodInfo method = typeof(Program).GetMethod("CreateObject", BindingFlags.Static | BindingFlags.NonPublic);
var properties = typeof(Pet).GetProperties().Where(pi => pi.Name == "Name"); //will be defined by user
Expression selectorBody = Expression.Call(method, Expression.Constant(properties));
Expression selector = Expression.Lambda(selectorBody, pe);
Expression res = Expression.Call(typeof(Enumerable), "Select", new[] { typeof(Pet), CreateType(properties) }, eList, selector);

我想做的是在运行时使用 Reflection.Emit 创建一个类型(上面代码中的方法“CreateType”，它在我的一些项目中使用并且看起来不错)并以某种方式传递它以调用“Select "，但我遇到异常:

No generic method 'Select' on type 'System.Linq.Enumerable' is compatible with the supplied type arguments and arguments.

有什么建议吗？

Upd 我真正的问题是为更复杂的运行时类型的“加入”调用构建表达式树，所以我决定询问“选择”，因为我有相同的最后一行异常 (Expression.Call(...))

Upd2 包括我的辅助方法和编辑的主要代码，但这不是主要问题。

static Type CreateType(IEnumerable<PropertyInfo> properties) {
        TypeBuilder typeBuilder = CreateTypeBuilder("ResultDynamicAssembly", "ResultModule", "ResultType");
        foreach (PropertyInfo propertyInfo in properties) {
            CreateAutoImplementedProperty(typeBuilder, propertyInfo.Name, propertyInfo.PropertyType);
        }
        return typeBuilder.CreateType();
    }

    static object CreateObject(IEnumerable<PropertyInfo> properties) {
        Type type = CreateType(properties); 
        return Activator.CreateInstance(type);
    }

Answer 1

您可以通过从等式中删除动态类型来简化此问题。您可以使用下面的代码重现相同的问题，它做的事情完全相同，但没有动态类型。

static class Program
{
    private static void Main(string[] args)
    {
        var list = new List<Pet>();
        var eList = Expression.Constant(list);
        var pe = Expression.Parameter(typeof(Pet), "p");
        var method = typeof(Program).GetMethod("CreateObject", BindingFlags.Static | BindingFlags.NonPublic);
        var properties = typeof(Pet).GetProperties().Where(pi => pi.Name == "Name"); //will be defined by user
        var selectorBody = Expression.Call(method, Expression.Constant(properties));
        var selector = Expression.Lambda(selectorBody, pe);
        var res = Expression.Call(typeof(Enumerable), "Select", new[] { typeof(Pet), CreateType(properties) }, eList, selector);
    }

    private static Type CreateType(IEnumerable<PropertyInfo> properties)
    {
        return typeof (DynamicType);
    }

    private static object CreateObject(IEnumerable<PropertyInfo> properties)
    {
        var type = CreateType(properties);
        return  Activator.CreateInstance(type);
    }

    class Pet
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    class DynamicType
    {
        public string Name { get; set; }
    }
}

所以问题出在CreateObject的方法签名上。由于其返回类型不是动态类型，因此 lambda 无效。您可以通过更改 CreateObject 的类型来查看这一点。

    // this works fine
    private static DynamicType CreateObject(IEnumerable<PropertyInfo> properties)
    {
        var type = CreateType(properties);
        return  (DynamicType) Activator.CreateInstance(type);
    }

由于您处理的是动态类型，因此您需要构建一个表达式以将 CreateObject 的结果转换为您的动态类型。尝试使用这样的东西:

        // create dynamic type
        var properties = typeof(Pet).GetProperties().Where(pi => pi.Name == "Name"); //will be defined by user
        var dynamicType = CreateType(properties);

        // build expression
        var list = new List<Pet>();
        var eList = Expression.Constant(list);
        var pe = Expression.Parameter(typeof(Pet), "p");
        var createObjectMethod = typeof(Program).GetMethod("CreateObject", BindingFlags.Static | BindingFlags.NonPublic);
        var createObjectCall = Expression.Call(createObjectMethod, Expression.Constant(properties));
        var castExpression = Expression.Convert(createObjectCall, dynamicType);
        var selectorExpression = Expression.Lambda(castExpression, pe);
        var res = Expression.Call(typeof(Enumerable), "Select", new[] { typeof(Pet), dynamicType }, eList, selectorExpression);