C#中IQueryable按时间段+额外列分组的实现方案（兼容SQL UDF）

核心思路 #

放弃Dynamic LINQ，改用表达式树构建动态分组键，结合EF Core的[DbFunction]特性映射SQL自定义函数，实现时间周期（年/季/月/周/日）+额外字段（ClientId/AssignedTo等）的分组需求。

步骤1：映射SQL自定义函数 #

先把SQL中的GetWeekNumber函数映射到C#方法，让EF Core能将其转换成SQL调用：

public class YourDbContext : DbContext
{
    // 映射SQL自定义函数，函数名要和数据库中完全一致
    [DbFunction("GetWeekNumber")]
    public static int GetWeekNumber(DateTime date)
    {
        // 仅用于LINQ翻译，运行时不会执行
        throw new NotImplementedException("此方法仅用于LINQ to SQL转换");
    }
}

步骤2：定义时间周期枚举 #

public enum TimePeriod
{
    Year,
    Quarter,
    Month,
    Week,
    Day
}

步骤3：用表达式树实现通用分组方法 #

这个方法能动态组合时间周期键和任意数量的额外分组字段，完全强类型，不依赖Dynamic LINQ：

public static class QueryableGroupExtensions
{
    public static IQueryable<IGrouping<object, T>> GroupByTimePeriodAndExtras<T>(
        this IQueryable<T> query,
        Expression<Func<T, DateTime>> dateSelector,
        TimePeriod timePeriod,
        params Expression<Func<T, object>>[] extraGroupSelectors)
    {
        // 1. 生成时间周期对应的分组表达式
        var timeKeyExpr = BuildTimeKeyExpression(dateSelector, timePeriod);

        // 2. 收集所有分组键表达式：时间键 + 额外字段
        var allKeyExprs = new List<Expression> { timeKeyExpr };
        allKeyExprs.AddRange(extraGroupSelectors.Select(e => e.Body));

        // 3. 构建ValueTuple作为分组键（LINQ to SQL完美支持）
        var tupleType = GetValueTupleType(allKeyExprs.Count);
        var tupleCtor = tupleType.GetConstructors().First();
        var tupleArgs = allKeyExprs
            .Select((expr, idx) => Expression.Convert(expr, tupleCtor.GetParameters()[idx].ParameterType))
            .ToList();

        // 4. 创建分组选择器表达式
        var keySelector = Expression.Lambda<Func<T, object>>(
            Expression.New(tupleCtor, tupleArgs),
            dateSelector.Parameters);

        return query.GroupBy(keySelector);
    }

    // 生成对应时间周期的分组表达式
    private static Expression BuildTimeKeyExpression<T>(Expression<Func<T, DateTime>> dateSelector, TimePeriod period)
    {
        var dateExpr = dateSelector.Body;
        return period switch
        {
            TimePeriod.Year => Expression.Property(dateExpr, nameof(DateTime.Year)),
            TimePeriod.Quarter => Expression.Add(
                Expression.Divide(Expression.Subtract(Expression.Property(dateExpr, nameof(DateTime.Month)), Expression.Constant(1)), Expression.Constant(3)),
                Expression.Constant(1)),
            TimePeriod.Month => Expression.Property(dateExpr, nameof(DateTime.Month)),
            TimePeriod.Week => Expression.Call(
                typeof(YourDbContext).GetMethod(nameof(YourDbContext.GetWeekNumber))!,
                dateExpr),
            TimePeriod.Day => Expression.Property(dateExpr, nameof(DateTime.Date)), // 按日期分组，而非日序号
            _ => throw new ArgumentOutOfRangeException(nameof(period))
        };
    }

    // 根据分组字段数量获取对应的ValueTuple类型
    private static Type GetValueTupleType(int fieldCount)
    {
        return fieldCount switch
        {
            1 => typeof(ValueTuple<>),
            2 => typeof(ValueTuple<,>),
            3 => typeof(ValueTuple<,,>),
            4 => typeof(ValueTuple<,,,>),
            _ => throw new ArgumentException("最多支持4个分组字段，可按需扩展")
        }.MakeGenericType(allKeyExprs.Select(e => e.Type).ToArray());
    }
}

步骤4：使用示例 #

// 假设你的实体是Task，包含CreatedDate、ClientId、AssignedTo字段
var db = new YourDbContext();
var taskQuery = db.Tasks.Where(t => t.Status == "Completed");

// 按周+ClientId+AssignedTo分组
var groupedTasks = taskQuery.GroupByTimePeriodAndExtras(
    t => t.CreatedDate,
    TimePeriod.Week,
    t => t.ClientId,
    t => t.AssignedTo);

// 遍历分组结果
foreach (var group in groupedTasks)
{
    // 解构ValueTuple分组键（注意类型要和你的字段匹配）
    var (weekNumber, clientId, assignedTo) = ((int, Guid, string))group.Key;
    var taskCount = group.Count();
    Console.WriteLine($"周{weekNumber} | 客户{clientId} | 负责人{assignedTo}：完成{taskCount}个任务");
}

替代方案：固定分组字段的简化写法 #

如果你的分组字段（ClientId/AssignedTo）固定，不想用表达式树，可以直接写针对性的分组方法，代码更直观：

public static IQueryable<IGrouping<(int WeekNumber, Guid ClientId, string AssignedTo), Task>> GroupByWeekAndTaskOwners(this IQueryable<Task> query)
{
    return query.GroupBy(t => new 
    {
        WeekNumber = YourDbContext.GetWeekNumber(t.CreatedDate),
        t.ClientId,
        t.AssignedTo
    })
    // 转换为ValueTuple方便解构
    .Select(g => Grouping.Create((g.Key.WeekNumber, g.Key.ClientId, g.Key.AssignedTo), g));
}

注：Grouping.Create是EF Core提供的分组创建方法，需引用Microsoft.EntityFrameworkCore命名空间。

内容的提问来源于stack exchange，提问作者Safi Mustafa