【发布时间】：2013-11-19 10:20:10
【问题描述】：
我最近提出了一个有趣的问题，流畅的方法应该返回什么？他们应该改变当前对象的状态还是创建一个具有新状态的全新对象？
如果这个简短的描述不是很直观，这里有一个（不幸的是）冗长的例子。它是一个计算器。它执行非常繁重的计算，这就是他通过异步回调返回结果的原因：
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 是一个普通的，它返回 this：
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。
【问题讨论】：
-
这本质上是在询问您是否应该使用不可变或可变对象。您是否使用流畅的界面实际上与这个问题无关。
-
@HighCore 你是否在用 C# 和 Java 标记的问题试图引发激烈的战争？
-
@HighCore 仅供参考，当你说“
不支持 anything”之类的话，然后声称明显的双曲线陈述是“客观的技术事实”，它对你的反映相当差。 -
@Servy 好吧，不完全是，我会说。我想说我在问是否应该将可变或不可变对象与流利的 api 结合使用。问题出现了，因为无论我在哪里谷歌，我都只看到可变流畅的 API，我问自己 - 为什么？也许有什么我不明白的？
-
@GusRustam 真的，因为我宁愿说反话。大多数不可变对象的 API 本质上都是流畅的，如果它不仅仅是一个数据持有者对象的话。看看 string、int、IEnumerable 等。另一方面，可变对象很少有流畅的 API。你会发现更流畅的 API 是不可变的而不是可变的。无论如何，我的观点是你不要坐下来说，“我需要一个流畅的 API，对象应该是不可变的还是可变的？”相反，您应该决定“这个对象应该是可变的还是不可变的”，然后然后决定它的 API 应该是什么样子。
标签： c# java oop design-patterns fluent-interface