如何创建表达皇宫树选择一个匿名的类型

https://stackoverflow.com/questions/606104

03-07-2019
|

题

我希望产生以下选择声明，动态使用的表达树木：

var v = from c in Countries
        where c.City == "London"
        select new {c.Name, c.Population};

我曾作出如何产生的

var v = from c in Countries
        where c.City == "London"
        select new {c.Name};

但我似乎无法找到一个构造/重载，让我指定多个性我选择lambda。

解决方案

如上所述，这可以通过Reflection Emit和我在下面包含的帮助类来完成。下面的代码是一项正在进行中的工作，因此请将其视为值得的......“它适用于我的盒子”。 SelectDynamic方法类应该放在静态扩展方法类中。

正如预期的那样，您不会获得任何Intellisense，因为直到运行时才创建类型。适用于后期数据控件。

public static IQueryable SelectDynamic(this IQueryable source, IEnumerable<string> fieldNames)
{
    Dictionary<string, PropertyInfo> sourceProperties = fieldNames.ToDictionary(name => name, name => source.ElementType.GetProperty(name));
    Type dynamicType = LinqRuntimeTypeBuilder.GetDynamicType(sourceProperties.Values);

    ParameterExpression sourceItem = Expression.Parameter(source.ElementType, "t");
    IEnumerable<MemberBinding> bindings = dynamicType.GetFields().Select(p => Expression.Bind(p, Expression.Property(sourceItem, sourceProperties[p.Name]))).OfType<MemberBinding>();

    Expression selector = Expression.Lambda(Expression.MemberInit(
        Expression.New(dynamicType.GetConstructor(Type.EmptyTypes)), bindings), sourceItem);

    return source.Provider.CreateQuery(Expression.Call(typeof(Queryable), "Select", new Type[] { source.ElementType, dynamicType },
                 Expression.Constant(source), selector));
}



public static class LinqRuntimeTypeBuilder
{
    private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
    private static AssemblyName assemblyName = new AssemblyName() { Name = "DynamicLinqTypes" };
    private static ModuleBuilder moduleBuilder = null;
    private static Dictionary<string, Type> builtTypes = new Dictionary<string, Type>();

    static LinqRuntimeTypeBuilder()
    {
        moduleBuilder = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run).DefineDynamicModule(assemblyName.Name);
    }

    private static string GetTypeKey(Dictionary<string, Type> fields)
    {
        //TODO: optimize the type caching -- if fields are simply reordered, that doesn't mean that they're actually different types, so this needs to be smarter
        string key = string.Empty;
        foreach (var field in fields)
            key += field.Key + ";" + field.Value.Name + ";";

        return key;
    }

    public static Type GetDynamicType(Dictionary<string, Type> fields)
    {
        if (null == fields)
            throw new ArgumentNullException("fields");
        if (0 == fields.Count)
            throw new ArgumentOutOfRangeException("fields", "fields must have at least 1 field definition");

        try
        {
            Monitor.Enter(builtTypes);
            string className = GetTypeKey(fields);

            if (builtTypes.ContainsKey(className))
                return builtTypes[className];

            TypeBuilder typeBuilder = moduleBuilder.DefineType(className, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Serializable);

            foreach (var field in fields)                    
                typeBuilder.DefineField(field.Key, field.Value, FieldAttributes.Public);

            builtTypes[className] = typeBuilder.CreateType();

            return builtTypes[className];
        }
        catch (Exception ex)
        {
            log.Error(ex);
        }
        finally
        {
            Monitor.Exit(builtTypes);
        }

        return null;
    }


    private static string GetTypeKey(IEnumerable<PropertyInfo> fields)
    {
        return GetTypeKey(fields.ToDictionary(f => f.Name, f => f.PropertyType));
    }

    public static Type GetDynamicType(IEnumerable<PropertyInfo> fields)
    {
        return GetDynamicType(fields.ToDictionary(f => f.Name, f => f.PropertyType));
    }
}

其他提示

接受的答案非常有用，但我需要更接近真实匿名类型的东西。

真正的匿名类型具有只读属性，用于填充所有值的构造函数，用于比较每个属性的值的Equals / GetHashCode实现，以及包含每个属性的名称/值的实现ToString 。（参见 https://msdn.microsoft.com/en-us/library/bb397696 .aspx 获取匿名类型的完整描述。）

基于匿名类的定义，我在 https://github.com/dotlattice/LatticeUtils/blob/master/LatticeUtils/AnonymousTypeUtils.cs 。该项目还包含一些单元测试，以确保假匿名类型的行为与真实类型相同。

以下是如何使用它的一个非常基本的例子：

AnonymousTypeUtils.CreateObject(new Dictionary<string, object>
{
    { "a", 1 },
    { "b", 2 }
});

另外，另一个注意事项：我发现当使用带有Entity Framework的动态匿名类型时，必须使用<！> quot; members <！>来调用构造函数。参数集。例如：

Expression.New(
    constructor: anonymousType.GetConstructors().Single(), 
    arguments: propertyExpressions,
    members: anonymousType.GetProperties().Cast<MemberInfo>().ToArray()
);

如果你使用了其中一个版本的Expression.New，它不包含<！> quot; members <！> quot;参数，实体框架不会将其识别为匿名类型的构造函数。所以我认为这意味着真正的匿名类型的构造函数表达式将包含<！> quot; members <！> quot;信息。

你可以在这里使用IQueryable-Extensions，它是<！>引用的解决方案的实现; Ethan J. Brown <！>“：

https://github.com/thiscode/DynamicSelectExtensions

扩展动态构建匿名类型。

然后你可以这样做：

var YourDynamicListOfFields = new List<string>(

    "field1",
    "field2",
    [...]

)
var query = query.SelectPartially(YourDynamicListOfFields);

也许有点晚，但可能对某人有帮助。

您可以从实体中选择生成动态选择DynamicSelectGenerator。

public static Func<T, T> DynamicSelectGenerator<T>()
            {
                // get Properties of the T
                var fields = typeof(T).GetProperties().Select(propertyInfo => propertyInfo.Name).ToArray();

            // input parameter "o"
            var xParameter = Expression.Parameter(typeof(T), "o");

            // new statement "new Data()"
            var xNew = Expression.New(typeof(T));

            // create initializers
            var bindings = fields.Select(o => o.Trim())
                .Select(o =>
                {

                    // property "Field1"
                    var mi = typeof(T).GetProperty(o);

                    // original value "o.Field1"
                    var xOriginal = Expression.Property(xParameter, mi);

                    // set value "Field1 = o.Field1"
                    return Expression.Bind(mi, xOriginal);
                }
            );

            // initialization "new Data { Field1 = o.Field1, Field2 = o.Field2 }"
            var xInit = Expression.MemberInit(xNew, bindings);

            // expression "o => new Data { Field1 = o.Field1, Field2 = o.Field2 }"
            var lambda = Expression.Lambda<Func<T, T>>(xInit, xParameter);

            // compile to Func<Data, Data>
            return lambda.Compile();
        }

并使用此代码：

var result = dbContextInstancs.EntityClass.Select(DynamicSelectGenerator<EntityClass>());

我不相信你能够实现这一目标。虽然当你做select new { c.Name, c.Population }时，你似乎并没有创建一个实际的课程。如果您查看Reflector中的编译输出或原始IL，您将能够看到它。

你会有一个看起来像这样的课程：

[CompilerGenerated]
private class <>c__Class {
  public string Name { get; set; }
  public int Population { get; set; }
}

（好吧，我清理了一下，因为一个属性实际上只是一个get_Name()和set_Name(name)方法集）

你要做的是正确的动态类创建，这是在.NET 4.0发布之前不可用的东西（即使那时我也不确定它是否能够达到你想要的效果）。

您最好的解决方案是定义不同的匿名类，然后进行某种逻辑检查以确定要创建哪一个，并创建它可以使用对象System.Linq.Expressions.NewExpression

但是，如果您对基础LINQ提供程序真正变得非常核心，那么它（可能至少在理论上）可能会这样做。如果您编写自己的LINQ提供程序，则可以检测当前解析的表达式是否为Select，然后确定CompilerGenerated类，反映其构造函数并创建。

绝对不是一个简单的任务，但LINQ to SQL，LINQ to XML等都是如此。

您可以使用参数类，而不是使用匿名类型。在您的示例中，您可以创建如下参数类：

public struct ParamClass {
    public string Name { get; set; };
    public int Population { get; set; };
}

<！>＃8230;并将其放入您的选择中：

var v = from c in Countries
        where c.City == "London"
        select new ParamClass {c.Name, c.Population};

你得到的是IQueryable<ParamClass>类型的东西。

这编译，我不知道它是否有效......

myEnumerable.Select((p) => { return new { Name = p.Name, Description = p.Description }; });

假设p是你的变换，并且select语句返回一个anon类型，使用lambda的函数声明。

编辑：我也不知道你将如何动态生成它。但至少它告诉你如何使用select lambda返回一个带有多个值的anon类型

EDIT2：

您还必须记住，c＃编译器实际上生成了anon类型的静态类。所以anon类型确实在编译后有一个类型。因此，如果您在运行时生成这些查询（我假设您是这样），您可能必须使用各种反射方法构建一个类型（我相信您可以使用它们来动态创建类型）将创建的类型加载到执行上下文中在生成的输出中使用它们。

我认为大多数事情都已经回答了-由于所说的，你需要一些类将返回 Select 法。一旦你有类，可以使用 System.Linq.Expressions.NewExpression 创建方法的表达。

如果你真的想要做到这一点，可以产生类在运行时也是。这是一个更多的工作，因为它不能使用皇宫表达的树木，但这是可能的。你可以使用 System.Reflection.Emit 名字空间来这样做-我只是做了一个快速搜索和这是一篇文章，说明了这一点：

引入到创造的动态型的反映。这些的

您可以使用动态表达式API，它允许您动态构建您的选择语句，如下所示：

 Select("new(<property1>,<property2>,...)");

您需要LINQ中的Dynamics.cs文件和Visual Studio的语言示例才能工作，两者都链接在此页面。您还可以在同一个网址上看到一个显示此操作示例的工作示例。

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow