策略模式正确吗？

Question

我希望你能帮助我解决我的问题：

我有一堂课正在做肥皂通话。但是如果肥皂定义发生变化，我将不得不编写一个新类或继承它等。 所以我找到了写这样的解决方案：

switch(version)
{
  case "1.0":
     saopV1.getData()
  case "2.0":
     soapV2.getData()
}

嗯，我知道代码很糟糕。然后我读到了有关策略模式的内容，我想，哇，这就是我需要摆脱这个糟糕的 switch-case 的东西：

abstract SoapVersion
{
    public SoapVersion GetSoapVersion(string version)
    {
         //Damn switch-case thing
         //with return new SoapV1() and return new SoapV2()
    }
    public string[] virtual getData()
    {
          //Basic Implementation
    }
}

class SoapV1:SoapVersion
{
       public override string[] getData()
       {
           //Detail Implementation
       }
}

class SoapV2:SoapVersion
{//the same like soapv1}

但我无法避免在代码中使用“ifs”或 switch case。使用面向对象技术可以实现这一点吗？

编辑： GetSoapVersion-Function 应该是静态的

Answer 1

这或多或少是以美丽的方式做到这一点的正确方法。
在代码中的某个时刻，您必须决定是否必须使用 v1 还是 v2，因此无论如何您都必须有一个条件语句（if 或 switch）。但是，当使用策略和工厂（工厂方法或工厂类）时，您已经集中了该决策。

不过，我会将抽象类上的工厂方法设为静态。
另外，我将利用模板方法模式：即一​​个公共的、不可重写的 GetData 方法，该方法调用应在具体实现中重写的受保护的虚拟（抽象）方法。

public abstract class SoapProcessor
{

    protected SoapProcessor() { /* protected constructor since public is of no use */  }

    public static SoapProcessor Create( SoapVersion version )
    {
          switch( version )
          {
               case SoapVersion.Version1 : return new SoapV1Processor();
               case SoapVersion.Version2 : return new SoapV2Processor();
               default: throw new NOtSupportedException();
          }
    }


    public string[] GetData()
    {
         return GetDataCore();
    }

    protected abstract GetDataCore();
 }

}

Answer 2

如果您的 switch-case 只在工厂中使用，或者在代码中到处都有，那就有区别了。您可以在一个点上做出决定（选择什么实现）。

Answer 3

在类似的情况下，我使用以下标准在反射和 if/case 之间进行选择：如果应动态添加新版本支持（如插件），我选择反射，否则 - if/case 。正如其他答案中提到的，它应该在工厂方法内提供一个创建事物的地方。值得一提的是，策略是一种行为模式，而您要求的看起来像是创造性的。

Answer 4

您不需要 switch 或 if 语句。
只需使用委托即可。
即，抽象类的具体实现将根据需要执行（即 SoapV1、SoapV2 等），并且客户端在对象引用中设置适当的实例。
您只有对基类的引用，适当的子类由客户端设置。您的代码仅调用基类的方法（在运行时是派生实现之一）。例如一个示例（免责声明：尚未编译代码。仅是一个示例）

public abstract class SoapHandler
{

    protected abstract string[] getData();
 }

public class SoapHandlerV1 extends SoapHandler
{

    public string[] getData(){
        //V1 implementation
    }

}
public class SoapHandlerV2 extends SoapHandler
{

    public string[] getData(){
        //V2 implementation
    }

}


public class SoapProcessor{

    public SoapHandler soapHandler;

    public setSoapHandler(SoapHandler h)
    {
                soapHandler = h;
    }

    public String[] getData(){
        //delegate to specific version
        soapHandler->getData();
    }
}


//in your code
SoapProcessor soap = new SoapProcessor();
soap.setSoapHandler(new SoapHandlerV1());
String[] soapData = soap.getData();//Will get the appropriate version
//use soap data
//do stuff

如果不清楚，请检查 GoF 的策略示例以了解我的意思

Answer 5

因为 version 仅在运行时才知道，所以它肯定会归结为某些条件（如果或切换或使用字符串和原型之间的映射等）。

因此，有价值的目标是减少条件数量/隔离变化点。

Answer 6

您应该针对接口而不是实现进行编程。

有一个单独的服务接口，您可以从客户端使用它。

public interface IService
{
    string[] GetData();
}

并将您的客户端编码为 -

IService srvice = ServiceFactory.GetProxy();
string[] value = service.GetData();

这样，当服务代理更改时，您的客户端代码不会更改。

然后，您首先可以将用于创建适当代理的条件逻辑移至 ServiceFactory 类。稍后，您可以使用以下技术更改它以删除条件逻辑，例如 -

1. 从配置文件中读取实现类和程序集名称并使用反射创建它。
2. 创建一个代理实例字典，以肥皂版本为键。