流畅的 API - 返回这个还是新的？

我最近提出了一个有趣的问题，流利的方法应该返回什么？他们应该改变当前对象的状态还是创建一个具有新状态的全新对象？

如果这个简短的描述不是很直观，这里有一个（不幸的是）冗长的例子。它是一个计算器。它执行非常繁重的计算，这就是为什么他通过异步回调返回结果的原因：

public interface ICalculator {
    // because calcualations are too lengthy and run in separate thread
    // these methods do not return values directly, but do a callback
    // defined in IFluentParams
    void Add(); 
    void Mult();
    // ... and so on
}

因此，这是一个设置参数和回调的流畅接口：

public interface IFluentParams {
    IFluentParams WithA(int a);
    IFluentParams WithB(int b);
    IFluentParams WithReturnMethod(Action<int> callback);
    ICalculator GetCalculator();
}

对于这个接口实现，我有两个有趣的选择。我会展示他们俩，然后我会写下我发现他们每个人的好坏。

因此，first 是通常的，返回以下内容：

public class FluentThisCalc : IFluentParams {
    private int? _a;
    private int? _b;
    private Action<int> _callback;

    public IFluentParams WithA(int a) {
        _a = a;
        return this;
    }

    public IFluentParams WithB(int b) {
        _b = b;
        return this;
    }

    public IFluentParams WithReturnMethod(Action<int> callback) {
        _callback = callback;
        return this;
    }

    public ICalculator GetCalculator() {
        Validate();
        return new Calculator(_a, _b);
    }

    private void Validate() {
        if (!_a.HasValue)
            throw new ArgumentException("a");
        if (!_b.HasValue)
            throw new ArgumentException("bs");
    }
}

第二个版本更复杂，每次状态更改时都会返回一个新对象：

public class FluentNewCalc : IFluentParams {
    // internal structure with all data
    private struct Data {
        public int? A;
        public int? B;
        public Action<int> Callback;

        // good - data logic stays with data
        public void Validate() {
            if (!A.HasValue)
                throw new ArgumentException("a");
            if (!B.HasValue)
                throw new ArgumentException("b");
        }
    }

    private Data _data;

    public FluentNewCalc() {
    }

    // used only internally
    private FluentNewCalc(Data data) {
        _data = data;
    }

    public IFluentParams WithA(int a) {
        _data.A = a;
        return new FluentNewCalc(_data);
    }

    public IFluentParams WithB(int b) {
        _data.B = b;
        return new FluentNewCalc(_data);
    }

    public IFluentParams WithReturnMethod(Action<int> callback) {
        _data.Callback = callback;
        return new FluentNewCalc(_data);
    }

    public ICalculator GetCalculator() {
        Validate();
        return new Calculator(_data.A, _data.B);
    }

    private void Validate() {
        _data.Validate();
    }
}

他们如何比较：

专业版第一（此）版本：

• 更简单、更短

• 常用

• 似乎更节省内存

• 还有什么？

专业版第二（新）版：

• 将数据存储在单独的容器中，允许分离数据逻辑和所有处理

• 允许我们轻松修复部分数据，然后填写其他数据并单独处理。看一看：

      var data = new FluentNewCalc()
          .WithA(1);
  
      Parallel.ForEach(new[] {1, 2, 3, 4, 5, 6, 7, 8}, b => {
          var dt = data
              .WithB(b)
              .WithReturnMethod(res => {/* some tricky actions */});
  
          // now, I have another data object for each value of b, 
          // and they have different callbacks.
          // if I were to do it with first version, I would have to create each 
          // and every data object from scratch
          var calc = dt.GetCalculator();
          calc.Add();
      });
  

在第二版中还有什么比这更好的呢？

• 我可以像这样实现WithXXX方法：

  public IFluentParams WithXXX(int xxx) {
      var data = _data;
      data.XXX = xxx;
      return new FluentNewCalc(data);
  }
  

  并使_data只读（即不可变），一些聪明的人说这是好的。

所以问题是，你认为哪种方式更好，为什么？附言：我用了c#，但很适用于java。