我有一个遗留方法，可以实时处理各种数量。有很多数据，这种方法基本上是一个大的if/switch混乱，它根据某些规则决定如何计算目标值，并对从每个设备接收到的每个样本进行计算（而且有很多）。它的签名类似于：
double Process(ITimestampedData data, IProcessingRule rule);
其中，ISample包含单个时间戳的多个不同量的值，而IProcessingRule定义了使用哪个值以及如何处理它以获得结果（然后可以将其与阈值进行比较）。
我想去掉所有的if和switch，并将其重构为一个工厂，为每个规则创建一个单独的处理方法，然后对输入数据运行这些方法。由于这些规则有各种参数，我也想看看是否有一种方法可以在编译时完全解析所有这些分支（好吧，运行时，但我指的是我调用一次工厂方法来"编译"我的处理委托）。
所以，我有这样的东西，但要复杂得多（更相互依赖的条件和各种规则）：
// this runs on each call
double result;
switch (rule.Quantity)
{
case QuantityType.Voltage:
{
Vector v;
if (rule.Type == VectorType.SinglePhase)
{
v = data.Vectors[Quantity.Voltage].Phases[rule.Phase];
if (rule.Phase == PhaseType.Neutral)
{
v = v * 2; // making this up just to make a point
}
}
else if (rule.Type == VectorType.Symmetry)
{
v = CalculateSymmetry(data.Vectors);
}
if (rule.TargetProperty == PropertyType.Magnitude)
{
result = v.Magnitude();
if (rule.Normalize)
{
result /= rule.NominalValue;
}
}
}
// ... this doesn't end so soon
变成这样：
// this is a factory method which will return a single delegate
// for each rule - and do it only once, at startup
Func<ITimestampedData, double> GetProcessor(IProcessingRule)
{
Func<ITimestampedData, Vectors> quantityGetter;
Func<Vectors, Vector> vectorGetter;
Func<Vector, double> valueGetter;
quantityGetter = data => data.Vectors[rule.Quantity];
if (rule.Type == VectorType.SinglePhase)
{
if (rule.Phase == PhaseType.Neutral)
vectorGetter = vectors => 2 * vectors.Phases[rule.Phase];
else
vectorGetter = vectors => vectors.Phases[rule.Phase];
}
else if (rule.Type == VectorType.Symmetry)
{
vectorGetter = vectors => CalculateSymmetry(vectors);
}
if (rule.TargetProperty == PropertyType.Magnitude)
{
if (rule.Normalize)
valueGetter = v => v.Magnitude() / rule.NominalValue;
else
valueGetter = v => v.Magnitude();
}
...
// now we just chain all delegates into a single "if-less" call
return data => valueGetter(vectorGetter(quantityGetter(data)));
}
但问题是：
- 我的方法中仍然有很多重复
- 我已经为多个委托调用切换了
if，性能并没有得到任何改善 - 尽管这个"链"是固定的，并且在工厂方法的末尾是已知的，但我仍然没有一个单独的编译方法来处理我的输入
最后，我的问题是：
有没有办法在我的工厂里用这些不同的代码块"构建"最终编译的方法
我知道我可以使用类似CSharpCodeProvider的东西，创建一个巨大的字符串，然后编译它，但我希望有更好的编译时支持和类型检查。
工厂
switch语句在代码中通常是一股臭味，您对它的感觉是完全正确的。但工厂是交换语句的理想场所。只是不要忘记工厂的职责是构造对象，所以要确保任何额外的逻辑都在工厂之外。此外，不要混淆工厂和工厂方法。当您有一组多态可交换类，并且您的工厂决定使用哪一个时，就会使用第一个。此外，它还有助于打破依赖关系。同时，工厂方法更像是静态构造函数，它知道构造对象的所有依赖关系。我建议对工厂方法要小心，而应该选择合适的工厂类。从SRP的角度考虑这一点——Factory的职责是在类承担一些业务责任的同时构造对象。当你使用工厂方法时，你的类有两个责任。
缩进
我试着遵循一个很好的规则，叫做"每个方法一个缩进级别"。这意味着，您只能有更多级别的缩进，不包括根缩进。这是一段有效且可读的代码：
function something() {
doSomething();
if (isSomethingValid()) {
doSomethingElse();
}
return someResult();
}
试着遵循这个规则，通过提取私有方法，你会看到代码变得更加清晰。
If/Else语句
事实证明，else语句总是可选的，并且您可以随时重构代码以使其不被使用。解决方案很简单——使用早期返回。您的方法将变得更短，可读性更强。
也许我的答案不足以解决你所有的问题，但至少它给了你一些思考的想法。
如果您正在使用遗留代码，我强烈建议您阅读Michael Feathers的《有效使用遗留代码》一书，当然还有Martin Fowler的《重构》。
考虑让您的规则具有更多的功能。你知道你想要什么规则，因为你传入了它。但在你当前的代码中，你会询问运行本身，以确定你要做什么计算。我建议你让规则更智能，并向规则询问结果。
例如，进行最多计算的规则是SinglePhaseNeutralVoltageMagnitudeNormalizedRule。
class SinglePhaseNeutralVoltageMagnitudeNormalizedRule implements IProcessingRule
{
double calculate(ITimestampedData data)
{
double result;
Vector v;
v = data.Vectors[Quantity.Voltage].Phases[Phase];
v = v * 2; // making this up just to make a point
result = v.Magnitude();
result /= NominalValue;
return result;
}
}
因此，过程方法变得更加简单
result = rule.calculate(data);
如果规则非常复杂，可以使用@SergeKuharev建议的工厂类来构建规则。此外，如果规则之间有很多共同的代码，可以重构到一个共同的地方。
例如，规范化可以是一个简单地包装另一个规则的规则。
class NormalizeRule IProcessingRule
{
private IProcessingRule priorRule;
private double nominalValue;
public NormalizeRule(IProcessingRule priorRule, double nominalValue)
{
priorRule = priorRule;
nominalValue = nominalValue;
}
public double calculate(ITimestampedData data)
{
return priorRule.calculate(data)/nominalValue;
}
}
因此，考虑到这一点，以及一个类SinglePhaseNeutralVoltageMagnitudeRule（如上所述，减去/=nomialValue），工厂可以将两者结合起来，通过组合生成SinglePhase NeutralvoltageMagnitudNrmalizedRule。