Oop 通过适当的软件工程原理消除复杂的if-else

CRM系统存在，假设40种不同的产品有60种不同的订单类型。每个产品的每个订单的处理都是不同的，尽管可能有相似之处。这些订单的流程逻辑代码涉及复杂的if-else语句。代码中的更改是非常危险的，因为它经常会在其他地方破坏一致性，因为if-else既长又复杂。开发人员很难跟踪其他的情况

如何使用OOP原则或其他方法设计系统，以便我们可以将代码更改的影响仅限于该订单类型和产品

更新：

我们出售服务服务可以组合并称为捆绑服务是可定制的，也可以向其中添加子组件。 在购买服务或修改现有服务时，订单由指定为订单项的定制组件发出。在OrderItems中，一些是MainOrderItem，其余的与MainOrderItem中的一个相关（记住捆绑服务）MainOrderItem直接与特定的服务相关。其他OrderItem与所选子组件相关。每个订单项都有自己的属性和资源

订单根据订单类型进行不同的处理。订单的处理分为几个阶段，有时可能需要一两天。复杂的逻辑是在这一点上，对40种不同的订单类型和60种不同的服务进行if-else条件检查

---

在我看来，不同的订单类型和服务在不同的类（40*60类）中具有处理逻辑，并以某种方式将它们联系起来。在订单处理的起点，基于服务和订单类型程序应解析特定类的对象以处理订单，这是唯一的条件检查。不同的处理逻辑封装在特定的类中。因此，订单和服务的处理逻辑没有混合。但是在多个订单和服务之间有一些共同的逻辑，我不想在不同的类中重复这些逻辑。所有这些结合在一起就是我寻找想法、概念和模式（策略、模板方法等）的地方。

下面只是一个简单的例子，说明如何解决问题。这个例子只考虑了服务而不是订单类型，因为这在你们的问题中太模糊了。我同意你问题下面的评论，需要更多的细节

using System;
using System.Collections;
using System.Collections.Generic;  
using System.Linq;

public class Program
{
    public static void Main()
    {
        // Set-up services
        var availableServices = new[]{
            new Service{ServiceId = 1, Name = "Consulting"},
            new Service{ServiceId = 2, Name = "Marketing"}
        };

        // Set-up processors (aka DI container)
        var processors = new Dictionary<int, IOrderProcessor>
        {
            {1, new ConsultingServiceProcessor()},
            {2, new MarketingServiceProcessor()}
        };

        // Generate orders
        var randOrderNumber = new Random();
        var listoOfOrders = availableServices
            .Select(s => new Order{
                Service = s,
                OrderNumber = randOrderNumber.Next(1000, 9999)
            })
            .ToList();


        // Process orders
        listoOfOrders
            .ForEach(order => 
                processors[order.Service.ServiceId]
                .Process(order));

    }

    public class Service
    {
        public int ServiceId {get;set;}
        public string Name {get;set;}
    }
    public interface IOrder
    {
        int OrderNumber {get;set;}
        Service Service  {get;set;}
    }

    public class Order : IOrder
    {
        public int OrderNumber  {get;set;}
        public Service Service  {get;set;}
    }
    public interface IOrderProcessor
    {
        void Process(IOrder order);
    }
    public abstract class BaseOrderProcessor : IOrderProcessor
    {
        // Common data
        public virtual void Process(IOrder order)
        {
            // Common logic
            Console.WriteLine(string.Format("Base logic executed for order nr. {0}", order.OrderNumber));
        }

        protected int CommonMethod()
        {
            return 1;
        }
        // Common internal logic
    }
    public class ConsultingServiceProcessor : BaseOrderProcessor
    {
        // Service specific implementation
        public override void Process(IOrder order)
        {
            // Service specific logic           
            base.Process(order); // skip if not needed

            var commonValue = CommonMethod();

            Console.WriteLine(string.Format("Consuling logic executed for order nr. {0}", order.OrderNumber));
        }
    }
    public class MarketingServiceProcessor : BaseOrderProcessor
    {
        // Service specific implementation
        public override void Process(IOrder order)
        {
            // Service specific logic

            base.Process(order); // skip if not needed

            var commonValue = CommonMethod();

            Console.WriteLine(string.Format("Consuling logic executed for order nr. {0}", order.OrderNumber));
        }
    }

}

使用系统；
使用系统集合；
使用System.Collections.Generic；
使用System.Linq；
公共课程
{
公共静态void Main（）
{
//设置服务
var availableServices=new[]{
新服务{ServiceId=1，Name=“Consulting”}，
新服务{ServiceId=2，Name=“Marketing”}
};
//设置处理器（又名DI容器）
var处理器=新字典
{
{1，新的ConsultingServiceProcessor（）}，
{2，新的MarketingServiceProcessor（）}
};
//生成订单
var randOrderNumber=new Random（）；
var listoOfOrders=可用服务
.选择（s=>新订单{
服务=s，
OrderNumber=randOrderNumber.Next（10009999）
})
.ToList（）；
//处理订单
利斯托福德
.ForEach（订单=>
处理器[订单.服务.服务ID]
.流程（订单）；
}
公务舱服务
{
public int ServiceId{get；set；}
公共字符串名称{get；set；}
}
公共接口路由器
{
int OrderNumber{get；set；}
服务服务{get；set；}
}
公共班级秩序：IOrder
{
public int OrderNumber{get；set；}
公共服务服务{get；set；}
}
公共接口处理器
{
作废流程（订单）；
}
公共抽象类BaseOrderProcessor:IOrderProcessor
{
//公共数据
公共虚拟作废流程（IOrder订单）
{
//共同逻辑
WriteLine（string.Format（“为订单编号{0}，订单编号执行的基本逻辑”）；
}
受保护的int CommonMethod（）
{
返回1；
}
//公共内部逻辑
}
公共类ConsultingServiceProcessor:BaseOrderProcessor
{
//特定于服务的实现
公共覆盖无效流程（IOrder订单）
{
//特定于服务的逻辑
base.Process（order）；//如果不需要，则跳过
var commonValue=CommonMethod（）；
WriteLine（string.Format（“为订单编号{0}，订单编号执行的查询逻辑”）；
}
}
公共类MarketingServiceProcessor:BaseOrderProcessor
{
//特定于服务的实现
公共覆盖无效流程（IOrder订单）
{
//特定于服务的逻辑
base.Process（order）；//如果不需要，则跳过
var commonValue=CommonMethod（）；
WriteLine（string.Format（“为订单编号{0}，订单编号执行的查询逻辑”）；
}
}
}

下面只是一个简单的例子，说明如何解决问题。这个例子只考虑了服务而不是订单类型，因为这在你们的问题中太模糊了。我同意这些评论