3

根据参考属性的 LINQ 表达式， 我已经实现了 Group By Extension，感谢 Daniel Hilgarth 的帮助，我需要帮助来为 GroupByMany 扩展它，如下所示

_unitOfWork.MenuSetRepository.Get().GroupBy("Role.Name","MenuText");

扩展方法

public static IEnumerable<IGrouping<string, TElement>> GroupBy<TElement>(this IEnumerable<TElement> elements,string property)
    {
        var parameter = Expression.Parameter(typeof(TElement), "groupCol");
        Expression<Func<TElement, string>> lambda;
        if (property.Split('.').Count() > 1)
        {
            Expression body = null;
            foreach (var propertyName in property.Split('.'))
            {
                Expression instance = body;
                if (body == null)
                    instance = parameter;
                body = Expression.Property(instance, propertyName);
            }
            lambda = Expression.Lambda<Func<TElement, string>>(body, parameter);
        }
        else
        {
            var menuProperty = Expression.PropertyOrField(parameter, property);
            lambda = Expression.Lambda<Func<TElement, string>>(menuProperty, parameter);    
        }

        var selector= lambda.Compile();
       return elements.GroupBy(selector);
    }
4

1 回答 1

7

这个答案由两部分组成：

  1. 为您的问题提供解决方案
  2. 教育您IEnumerable<T>以及IQueryable<T>两者之间的差异

第 1 部分：针对您当前问题的解决方案

新要求不像其他要求那样容易满足。其主要原因是按复合键分组的 LINQ 查询会导致在编译时创建匿名类型：

source.GroupBy(x => new { x.MenuText, Name = x.Role.Name })

这会产生一个新类，其中包含一个编译器生成的名称和两个属性MenuText和Name.
在运行时这样做是可能的，但实际上并不可行，因为这将涉及将 IL 发送到新的动态程序集中。

对于我的解决方案，我选择了一种不同的方法：
因为所有涉及的属性似乎都是类型string，所以我们分组的键只是由分号分隔的属性值的串联。
因此，我们的代码生成的表达式等价于以下内容：

source.GroupBy(x => x.MenuText + ";" + x.Role.Name)

实现这一点的代码如下所示：

private static Expression<Func<T, string>> GetGroupKey<T>(
    params string[] properties)
{
    if(!properties.Any())
        throw new ArgumentException(
            "At least one property needs to be specified", "properties");

    var parameter = Expression.Parameter(typeof(T));
    var propertyExpressions = properties.Select(
        x => GetDeepPropertyExpression(parameter, x)).ToArray();

    Expression body = null;
    if(propertyExpressions.Length == 1)
        body = propertyExpressions[0];
    else
    {
        var concatMethod = typeof(string).GetMethod(
            "Concat",
            new[] { typeof(string), typeof(string), typeof(string) });

        var separator = Expression.Constant(";");
        body = propertyExpressions.Aggregate(
            (x , y) => Expression.Call(concatMethod, x, separator, y));
    }

    return Expression.Lambda<Func<T, string>>(body, parameter);
}

private static Expression GetDeepPropertyExpression(
    Expression initialInstance, string property)
{
    Expression result = null;
    foreach(var propertyName in property.Split('.'))
    {
        Expression instance = result;
        if(instance == null)
            instance = initialInstance;
        result = Expression.Property(instance, propertyName);
    }
    return result;
}

这又是我在前 两个答案中展示的方法的扩展。

它的工作原理如下：

  1. 对于每个提供的深层属性字符串，通过GetDeepPropertyExpression. 这基本上是我在之前的答案中添加的代码。
  2. 如果只传递了一个属性，则直接将其用作 lambda 的主体。结果与我之前的答案中的表达式相同，例如x => x.Role.Name

  3. 如果传递了多个属性，我们将这些属性相互连接，并在它们之间使用分隔符，并将其用作 lambda 的主体。我选择了分号，但你可以使用任何你想要的。假设我们传递了三个属性 ( "MenuText", "Role.Name", "ActionName")，那么结果将如下所示：

    x => string.Concat(
        string.Concat(x.MenuText, ";", x.Role.Name), ";", x.ActionName)

    这与 C# 编译器为使用加号连接字符串的表达式生成的表达式相同，因此等效于：

    x => x.MenuText + ";" + x.Role.Name + ";" + x.ActionName

第 2 部分：教育你

您在问题中显示的扩展方法是一个非常糟糕的主意。
为什么？好吧，因为它适用于IEnumerable<T>. 这意味着这个 group by不是在数据库服务器上执行，而是在应用程序的内存中本地执行。此外，后面的所有 LINQ 子句（如 a Where）也在内存中执行！

如果您想提供扩展方法，您需要为IEnumerable<T>（在内存中，即 LINQ to Objects）和IQueryable<T>（对于要在数据库上执行的查询，如 LINQ to Entity Framework）执行此操作。
这与 Microsoft 选择的方法相同。对于大多数 LINQ 扩展方法，存在两种变体：一种适用于其上IEnumerable<T>，另一种适用于其IQueryable<T>存在于两个不同的类中Enumerable，以及Queryable. 比较这些类中方法的第一个参数。

所以，你想要做的是这样的：

public static IEnumerable<IGrouping<string, TElement>> GroupBy<TElement>(
    this IEnumerable<TElement> source, params string[] properties)
{
    return source.GroupBy(GetGroupKey<TElement>(properties).Compile());
}

public static IQueryable<IGrouping<string, TElement>> GroupBy<TElement>(
    this IQueryable<TElement> source, params string[] properties)
{
    return source.GroupBy(GetGroupKey<TElement>(properties));
}
于 2013-07-17T07:49:39.490 回答