如何在C#中对DataTable任意列执行自定义聚合操作？

核心需求 #

需要封装一个Calculator类，对DataTable的行子集执行自定义聚合操作：

• 支持指定任意列的聚合（如求和、平均值）
• 支持多列计算后的聚合（如one列与three列相加后求平均）
• 能够存储不同类型的聚合逻辑（如返回int的求和、返回double的平均值）

最初问题：desire的类型 #

你提到的desire本质是接收行集合、返回聚合结果的委托，最灵活的类型是Func<IEnumerable<DataRow>, TResult>，它允许调用者自定义从行到计算值的转换，再执行聚合。

现有实现的局限 #

你当前的DoAggregation<T>方法仅支持单列聚合，且无法存储不同类型的聚合委托（因为List<Func<IEnumerable<T>, T>>是强类型集合，无法同时容纳int、double等不同返回类型的委托）。

优化方案 #

1. 支持单列/多列聚合的通用方法 #

将行的转换逻辑完全开放给调用者，让聚合函数直接处理DataRow集合，既支持单列也支持多列计算：

public class Calculator
{
    private readonly List<DataRow> _data;

    public Calculator(List<DataRow> data)
    {
        _data = data;
    }

    // 通用聚合方法：接收自定义聚合逻辑
    public TResult DoAggregation<TResult>(Func<IEnumerable<DataRow>, TResult> aggregationFunc)
    {
        return aggregationFunc(_data);
    }
}

调用示例：

// 初始化计算器（传入行子集）
var dataRows = DataTable.AsEnumerable().ToList();
var myCalc = new Calculator(dataRows);

// 1. 单列求和
var sumThree = myCalc.DoAggregation(rows => rows.Sum(r => r.Field<int>("three")));

// 2. 单列求平均值
var avgTwo = myCalc.DoAggregation(rows => rows.Average(r => r.Field<int>("two")));

// 3. 多列计算后求平均值
var avgOnePlusThree = myCalc.DoAggregation(rows => rows.Average(r => r.Field<int>("one") + r.Field<int>("three")));

2. 存储不同类型的聚合逻辑 #

如果需要存储多个不同类型的聚合操作，可以通过非泛型接口统一封装：

定义聚合操作接口与实现

// 非泛型接口，统一执行入口
public interface IAggregationOperation
{
    object Execute(IEnumerable<DataRow> data);
}

// 泛型实现，封装具体聚合逻辑
public class AggregationOperation<TResult> : IAggregationOperation
{
    private readonly Func<IEnumerable<DataRow>, TResult> _aggregationFunc;

    public AggregationOperation(Func<IEnumerable<DataRow>, TResult> aggregationFunc)
    {
        _aggregationFunc = aggregationFunc;
    }

    public object Execute(IEnumerable<DataRow> data)
    {
        return _aggregationFunc(data);
    }
}

扩展Calculator类支持存储与批量执行

public class Calculator
{
    private readonly List<DataRow> _data;
    private readonly List<IAggregationOperation> _savedAggregations = new();

    public Calculator(List<DataRow> data)
    {
        _data = data;
    }

    public TResult DoAggregation<TResult>(Func<IEnumerable<DataRow>, TResult> aggregationFunc)
    {
        return aggregationFunc(_data);
    }

    // 保存聚合逻辑
    public void SaveAggregation<TResult>(Func<IEnumerable<DataRow>, TResult> aggregationFunc)
    {
        _savedAggregations.Add(new AggregationOperation<TResult>(aggregationFunc));
    }

    // 批量执行所有保存的聚合逻辑
    public IEnumerable<object> RunSavedAggregations()
    {
        return _savedAggregations.Select(op => op.Execute(_data));
    }
}

存储与批量执行示例：

// 保存不同类型的聚合逻辑
myCalc.SaveAggregation(rows => rows.Sum(r => r.Field<int>("three")));
myCalc.SaveAggregation(rows => rows.Average(r => r.Field<int>("two")));
myCalc.SaveAggregation(rows => rows.Average(r => r.Field<int>("one") + r.Field<int>("three")));

// 执行所有聚合并处理结果
var results = myCalc.RunSavedAggregations();
foreach (var result in results)
{
    if (result is int sumResult)
        Console.WriteLine($"求和结果：{sumResult}");
    else if (result is double avgResult)
        Console.WriteLine($"平均值结果：{avgResult:F2}");
}

方案优势 #

• 灵活性：支持单列、多列甚至更复杂的行级计算聚合
• 可扩展性：无需修改Calculator类，调用者可自定义任意聚合逻辑
• 类型兼容：通过非泛型接口实现不同类型聚合逻辑的统一存储与执行

内容的提问来源于stack exchange，提问作者Jason 'Bug' Fenter