2

编辑我想我可以问得更好（在这种情况下根本不需要代码）。(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”的调用，但是我得到例外：

类型“System.Linq.Enumerable”上没有通用方法“Select”与提供的类型参数和参数兼容。

有什么建议么？

更新我真正的问题是为运行时类型的“加入”调用构建一个表达式树，这更复杂，所以我决定询问“选择”，因为我在最后一行有相同的异常（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);
    }
4

2 回答 2

4

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

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);
于 2013-06-14T15:08:57.253 回答
-1

为每种类型创建一个工厂。您知道来源，所以它非常简单：

interface PetResultFactory<T>
{
    string TypeName {get; }
    List<T> Transform(IEnumerable<Pet> pets);
}

您必须在容器中注册所有可能的类型，并在 UI 上为用户显示注册的类型。当用户选择一个时，您知道如何创建该类型，因为它在工厂中进行了描述。

于 2013-06-14T14:11:17.380 回答