C#中如何捕获Func<..>的副作用？第三方数学库场景最佳实践

我使用了一个无法修改的数学库，其中的Calculate方法会迭代调用Func<double, double>类型的近似函数，代码如下：

public double Calculate(double startInput, Func<double, double> approximationFunc)
{
    var result = 0d;
    var max = 10;
    for (int i = 0; i < max; i++)
    {
        result = approximationFunc(startInput);
        //do some checks ...
        startInput = DoSomething();
    }
    return result;
}

但实际业务中，我的近似函数需要计算double结果之外的其他值并复用，目前我通过闭包捕获变量的方式实现：

public void BusinessLogic(double startInput)
{
    MyOtherResult myOtherResult = null;
    double myFunction(double input)
    {
        var result = ComputeMyResult(input);
        myOtherResult = ComputeMyOtherResult(result, someOtherStuff);
        return result;
    }

    var approximationResult = Calculate(startInput, myFunction);
    var myOtherApproximationResult = myOtherResult;
    // Do other stuff...
}

这个方案依赖数学库的迭代逻辑，并非理想实现。我不确定这是不是获取额外结果的最优方式，也想了解无副作用的实现方法，请问在C#中该如何解决？

1. 无副作用的优雅实现：自定义结果类型 #

既然原库只接受返回double的委托，但需要额外结果，可以定义一个不可变的结果结构体来同时承载主结果和附加数据，每次调用委托时生成新的实例，完全避免副作用：

首先定义承载多结果的类型：

public readonly struct CalculationResult
{
    public double MainResult { get; }
    public MyOtherResult OtherResult { get; }

    public CalculationResult(double mainResult, MyOtherResult otherResult)
    {
        MainResult = mainResult;
        OtherResult = otherResult;
    }
}

然后在业务逻辑中维护这个结果的状态：

public void BusinessLogic(double startInput)
{
    CalculationResult currentResult = default;

    double myFunction(double input)
    {
        var mainResult = ComputeMyResult(input);
        var otherResult = ComputeMyOtherResult(mainResult, someOtherStuff);
        currentResult = new CalculationResult(mainResult, otherResult);
        return mainResult;
    }

    var approximationResult = Calculate(startInput, myFunction);
    var myOtherApproximationResult = currentResult.OtherResult;
    // 后续业务处理
}

这种方式把附加结果的传递变得明确，比隐式捕获变量更易读，也符合无副作用的设计原则。

2. 简化闭包：用容器类封装状态 #

如果不想新增结构体，也可以用一个简单的容器类来封装附加结果，让闭包的副作用更清晰，避免直接捕获零散变量：

public class ResultContainer
{
    public MyOtherResult OtherResult { get; set; }
}

public void BusinessLogic(double startInput)
{
    var resultContainer = new ResultContainer();

    double myFunction(double input)
    {
        var mainResult = ComputeMyResult(input);
        resultContainer.OtherResult = ComputeMyOtherResult(mainResult, someOtherStuff);
        return mainResult;
    }

    var approximationResult = Calculate(startInput, myFunction);
    var myOtherApproximationResult = resultContainer.OtherResult;
    // 后续业务处理
}

这种写法比直接捕获null初始化的变量更直观，容器的作用一目了然，减少代码歧义。

3. 解决迭代逻辑依赖问题 #

你提到的闭包方案依赖原库迭代逻辑的问题确实存在——当前代码只能拿到最后一次调用委托生成的附加结果，如果原库的Calculate逻辑修改（比如循环次数变化、提前终止循环），你的附加结果就会出错。

如果需要收集所有迭代过程中的附加结果，可以在闭包里维护一个列表：

public void BusinessLogic(double startInput)
{
    var allOtherResults = new List<MyOtherResult>();

    double myFunction(double input)
    {
        var mainResult = ComputeMyResult(input);
        var otherResult = ComputeMyOtherResult(mainResult, someOtherStuff);
        allOtherResults.Add(otherResult);
        return mainResult;
    }

    var approximationResult = Calculate(startInput, myFunction);
    // 取最后一次的附加结果，或者遍历整个列表做处理
    var myOtherApproximationResult = allOtherResults.LastOrDefault();
    // 后续业务处理
}

这种方式不依赖原库的迭代次数，无论原库怎么调整循环逻辑，你都能拿到完整的附加结果序列。

内容的提问来源于stack exchange，提问作者A. Non