C# 现实生活中的程序员应该有多疯狂？

鉴于： 复杂算法

switch obj.field1 + "-" + obj.field2
case "A-A":
    return Sample(obj){Error = "Type can't be matched"}
case "A-B":
    {
    if(obj.field3 != null){
        var match = otherObjectCollection.FirstOrDefault(otherOb.field2 == obj.field3);
        return mathc != null? Sample(obj,match) : Sample(obj){Error="Can't find match"}
    }else{use field4...}
}
case "A-C":
{
var related = objectCollection.FirstOrDefault(parent.field4 == obj.field3);
if(related == null)
 return Sample(obj){Error = "Can't find parent"}
else {
  if(related.field3 != null){
       var match = otherObjectCollection.FirstOrDefault(otherOb.field2 == related.field3);
       return mathc != null? Samble(obj,match) : Sample(obj){Error="Can't find match"}
  }else{ use field 4 ...}

}
    }

等等。很多棘手的规则。我做出了下一个决定：

abstract class AggregationChain{
    protected MyObj Obj;
    abstract string Type{get;}
    abstract Priority Priority{get;}
    abstract bool Decide(MyObj obj);
    abstract Sample Aggregate(ICollection<MyObj> objects,ICollection<OtherObj> otherobjects);
    bool CanDecide(MyObj obj){
        if(Decide(obj)){
           Obj = obj;
           return true;
        }
        return false;
    }
 }

抽象类聚合链{
受保护的MyObj；
抽象字符串类型{get；}
抽象优先级{get；}
抽象布尔决策（MyObj obj）；
抽象样本聚合（ICollection对象、ICollection其他对象）；
布尔烛光灯（MyObj obj）{
如果（决定（obj））{
Obj=Obj；
返回true；
}
返回false；
}
}

因此，现在我可以使用链接，例如：

 class ABAggregationChainLink{

        string Type{get{return "A-B"}}
        Priority Priority{get{return Priority.High}}
        bool Decide(MyObj obj){ 
           return obj.fiel2 != null;
        }
        Sample Aggregate(ICollection<MyObj> objects,ICollection<OtherObj> otherobjects){
            var match = OtherObjectCollection.FirstOrDefault(otherOb.field2 == obj.field3);
            return mathc != null? Samble(obj,match) : Sample(obj){Error="Can't find match"}
        }

     }

class ABAggregationChainLink{
字符串类型{get{return“A-B”}
优先级{获取{返回优先级.高}
布尔决定（MyObj obj）{
返回obj.fiel2！=null；
}
示例聚合（ICollection对象、ICollection其他对象）{
var match=OtherObjectCollection.FirstOrDefault（otherOb.field2==obj.field3）；
return mathc！=null？Samble（obj，match）：Sample（obj）{Error=“找不到匹配项”}
}
}

在这个例子中，我需要再创建一个A-B链接来处理“else”情况。对于所有的切换情况，我需要创建不同的链接。这当然增加了类的数量和实现的时间，但是类更适合于单元测试，并且从我的观点来看，更具可扩展性和灵活性

问题：

abstract class AggregationChain{
    protected MyObj Obj;
    abstract string Type{get;}
    abstract Priority Priority{get;}
    abstract bool Decide(MyObj obj);
    abstract Sample Aggregate(ICollection<MyObj> objects,ICollection<OtherObj> otherobjects);
    bool CanDecide(MyObj obj){
        if(Decide(obj)){
           Obj = obj;
           return true;
        }
        return false;
    }
 }

我在想——可能是我对开闭和“好”过于兴奋了 编程”，对于现实生活中的应用程序，最好只创建 方法与开关和照顾可重复使用的零件

我有 在这里填充可能是更好的解决方案

---

注：这不是有效的C代码，我只是试图解释主要的逻辑。

当分析这样的东西时，你不能只看它现在是什么

• 该算法是否易于维护
• 有多容易 在不更改现有功能的情况下添加新规则
• 多容易啊 要测试吗
• 您是否需要在运行时添加新规则（插件架构）

在3例有一些if-ELSE的病例中，这两种情况可能都无关紧要。在40个案例中，有子案例和一个新的要求，即它都需要单元测试？我更喜欢按照规则对类进行干净的隔离（或者更可能是将带有lambda表达式的泛型类添加到规则集合中）

您的link类看起来不错，但仍然需要chain类将所有链接保存在一起，并确定要处理的链接。最终可能会有一个结构来替换switch语句，如：

Dictionary<String, Dictionary<String, List<Link>>> index;

if (index.ContainsKey(obj.Field1))
{
   var subIndex = index[obj.Field1];
   if (subIndex.ContainsKey(obj.Field2))
   {
      var linkList = subIndex[obj.Field2];
      foreach(var Link in linkList)
      {
          if (Link.Decide(obj))
          {
              return Link.Aggregate(objects, otherObjects);
          } 
      }
   }
}

---

我有一种强烈的感觉，它太复杂了。一个简单的转换可能更易于维护和阅读。你需要学会在学术和实践之间划清界限。我认为你是对的，但我无法想象这个规则会是什么样子？因为它们没有相似的结构。@Valentinvynogradskiy，如果不知道所有的规则，很难说，你需要仔细检查每一条规则，找出界面上最少的信息是什么，才能使用它们。我已经编辑了我的答案，以包含链上的更多细节