Question

我是设计模式的新手，因此对所有可用内容的了解有限。希望我可以围绕我正在尝试解决的问题提供一些细节，用户社区可以就使用什么样的设计模式以及如何实现它提供一些指导。

每种呼叫类型的返回对象都是相同的
基础类实现可以在某些枚举类型上完成（即ActionType = 1适用于ActionClass1但不适用于ActionClass2和ActionClass3
类参数因类型

例如：

public enum ActionType
{
   Action1,
   Action2,
   Action3
}

可能的工厂模式实施：

public static class ActionClass
{
        public static int DoAction(ActionType type, int val1, int val2)
        {
               switch (type)
               {
                  case Type1: 
                       return new ActionClass1(val1, val2).DoAction();
                       break;
                  default:
                       throw new NotImplementedException();                      
               }
         } 

         public static int DoAction(ActionType type, string val1)  
         {
             switch (type)
               {

                  case Type2: 
                       return new ActionClass2(val1).DoAction();
                       break;
                  case Type3:
                       return new ActionClass3(val1).DoAction();
                  default:
                        throw new NotImplementedException();                      
               }

         }
}

Answer 1

根据您的操作所代表的内容，您可能需要查看Strategy Pattern。否则，Factory Method Pattern看起来已经很合适了，虽然我可能会将方法更改为不立即执行操作，但会返回一个封装操作的对象，并在操作时使用TryXXX模式而不是异常不支持参数类型：

public static bool TryGetIntIntAction(
    ActionType type, out Func<int, int, int> func)
{
    switch (type)
    {
    case ActionType.Action1:
        func = (val1, val2) => new ActionClass1(val1, val2).DoAction();
        return true;
    default:
        func = null;
        return false;
    }
}

public static bool TryGetStringAction(
    ActionType type, out Func<string, int> func)
{
    switch (type)
    {
    case ActionType.Action2:
        func = val1 => new ActionClass2(val1).DoAction();
        return true;
    case ActionType.Action3:
        func = val1 => new ActionClass3(val1).DoAction();
        return true;
    default:
        func = null;
        return false;
    }
}

Answer 2

通过为每个ActionType创建一个类，重构类型切换的常用方法是多态。由于每个DoAction重载都使用不同的参数，因此您可以将这些参数封装在“参数对象”中，并使用泛型将每个操作类型与其参数类型相关联：

public abstract ActionClass<T>
{
    public abstract int DoAction(T parameter);
}

public class ActionClass2 : ActionClass<string>
{
    public override int DoAction(string parameter) { ... }
}

相同返回对象的设计模式选项，但不同的枚举类型值和参数值类型

2 个答案: