我最近提出了一个有趣的问题，流畅的方法应该返回什么？他们应该改变当前对象的状态还是创建一个具有新状态的全新对象？
如果这个简短的描述不是很直观，这里有一个（不幸的是）冗长的例子。它是一个计算器。它执行非常繁重的计算，这就是他通过异步回调返回结果的原因：
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();
}
对于这个接口实现，我有两个有趣的选择。我会展示他们两个，然后我会写出我认为他们每个人的好和坏。
所以，第一个是通常的，它返回这个：
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 只读（即不可变），一些聪明人说这很好。
所以问题是，你认为哪种方式更好，为什么？PS我使用了c#，但很可能适用于java。