所以，问题

Question

我的主要目标是创建一个动态组，并在NHibernate中使用它。

考虑这个有效的非动态示例：

_repository.Collection<User>().GroupBy(u => new { u.Active }).Select(s => s.Key, Count = s.Count())

现在，我创建一个动态对象来动态生成new { u.Active }部分：

    private Expression<Func<T, object>> CreateGrouping<T>(IEnumerable<string> by)
    {
        var dynamicTypeForGroup = GetDynamicTypeForGroup<T>(by);
        var sourceItem = Expression.Parameter(typeof(T));

        var bindings = dynamicTypeForGroup
            .GetFields()
            .Select(p => Expression.Bind(p, Expression.PropertyOrField(sourceItem, p.Name)))
            .Cast<MemberBinding>()
            .ToArray();
        return Expression.Lambda<Func<T, object>>(Expression.Convert(
            Expression.MemberInit(
                Expression.New(dynamicTypeForGroup.GetConstructor(Type.EmptyTypes)),
                bindings),
            dynamicTypeForGroup),
        sourceItem);
    }

类型是在方法GetDynamicTypeForGroup中生成的，然后用Expression.MemberInit(Expression.New(dynamicTypeForGroup.GetConstructor(Type.EmptyTypes)), bindings)实例化

这是类型的生成方式：

    private Type GetDynamicTypeForGroup<T>(IEnumerable<string> members)
    {
        var type = typeof(T);
        var dynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
            new AssemblyName(Guid.NewGuid().ToString()),
            AssemblyBuilderAccess.RunAndSave
        );
        var dynamicModule = dynamicAssembly.DefineDynamicModule(Guid.NewGuid().ToString());
        var typeBuilder = dynamicModule.DefineType(Guid.NewGuid().ToString());

        var properties = members.Select(prop => type.GetProperty(ObjectExtensions.NormilizePropertyName(prop)))
                            .Where(prop => prop != null)
                            .Cast<MemberInfo>();

        var fields = properties
            .Select(property => typeBuilder.DefineField(
                property.Name,
                ((PropertyInfo)property).PropertyType,
                FieldAttributes.Public
            )).Cast<FieldInfo>()
            .ToArray();

        GenerateEquals(typeBuilder, fields);
        GenerateGetHashCode(typeBuilder, fields);

        return typeBuilder.CreateType();
    }

所以，问题

如果我使用_repository.Collection<User>().GroupBy(u => new { u.Active })可以工作，但是如果我添加Select部分-.Select(s => s.Key, Count = s.Count())（或任何选择语句），则会得到以下 NotSupportedException：MemberInit

System.NotSupportedException：MemberInit em NHibernate.Linq.Visitors.HqlGeneratorExpressionVisitor.VisitExpression（表达式）（省略）

我的疑问是：

我知道NHibernate支持带有 group by 和匿名类型的Select语句，但是如果这种类型是用表达式树创建的，为什么它不能支持Select？

Answer 1

显然，NHibernate LINQ查询翻译器在MemberInitExpression选择器中不支持GroupBy。

但是为什么匿名类型有效？因为尽管表达式new { Active = u.Active }在语法上看起来像 MemberInitExpression（类初始值设定项），但实际上不是！

C＃编译器生成（并且NHibernate支持）的是通过参数NewExpression映射到类成员的带有参数的构造函数（Members）的调用-属性的第三个参数以下Expression.New重载：

public static NewExpression New (
    ConstructorInfo constructor,
    IEnumerable<Expression> arguments,
    IEnumerable<MemberInfo> members
)

这是问题的解决方案。在动态类型生成器中，生成一个参数与字段匹配的构造函数（并在体内分配相应的字段）：

var fields = properties
    .Select(property => typeBuilder.DefineField(
        property.Name,
        ((PropertyInfo)property).PropertyType,
        FieldAttributes.Public
    )).Cast<FieldInfo>()
    .ToArray();

GenerateConstructor(typeBuilder, fields); // <--

GenerateEquals(typeBuilder, fields);
GenerateGetHashCode(typeBuilder, fields);

return typeBuilder.CreateType();

，然后使用类似这样的内容：

private Expression<Func<T, object>> CreateGrouping<T>(IEnumerable<string> by)
{
    var keyType = GetDynamicTypeForGroup<T>(by);
    var sourceItem = Expression.Parameter(typeof(T));
    var members = keyType.GetFields();
    var arguments = members.Select(m => Expression.PropertyOrField(sourceItem, m.Name));
    var constructor = keyType.GetConstructor(members.Select(m => m.FieldType).ToArray());
    var newKey = Expression.New(constructor, arguments, members);        
    return Expression.Lambda<Func<T, object>>(newKey, sourceItem);
}

使用带有动态匿名对象的NHibernate在GroupBy中进行选择

所以，问题

1 个答案: