c# - 枚举组合的设计模式(方法参数)

Question

我有一段与此类似的代码:

public bool DoMyThings(EnumRootAction root, EnumChildAction child){
          switch(root){
               case EnumRootAction.Type1:
                                switch(child){
                                       case EnumChildAction.Ac1: 
                                                    // DO something
                                                    break;
                                        case EnumChildAction.Ac2: 
                                                    // DO something
                                                    break;
                                        default: // child is not child of type root
                                                return false;
                                }
                                break;
                case EnumRootAction.Type2:
                                switch(child){
                                       case EnumChildAction.Ac1: 
                                                    // DO something
                                                    break;
                                        case EnumChildAction.Ac3: 
                                                    // DO something
                                                    break;
                                        default: // child is not child of type root
                                                return false;
                                }
                                break;
                ... // etc...
                default: 
                    return false;                       
        }
        return true;
     }

但是，我确实认为这是一段难看的代码...:) ...此服务的“消费者”不知道有效的根/子节点的正确组合，可能会传递错误一。

我想过将它“吐”到几个方法中，例如:DoMyThingsForRootType1(EnumChildActionForType1 child) 但从长远来看，这在我的案例中并不是那么容易改变。我解释一下原因:如果我的服务签名不断变化，我需要更新所有实时客户端的服务协议(protocol)....更新源代码并再次部署....目前客户端可以简单地进行通过更改一些 app.settings 值手动更改这些更改。

此时我提供了一张包含正确组合的纸，但在我看来这也是废话。

也许我只是从一个角度来看这件事，不知何故我无法扩大我的视野……这就是为什么我想听听你们的一些反馈……

有更好的设计模式吗？ 至少以某种方式将有效组合通知服务的客户....

谢谢。

Answer 1

如果您可以使用接口(interface)或基类而不是枚举，您就可以利用面向对象的力量来确定如何评估组合。这允许您以易于理解和易于维护的方式对根/子操作功能进行分组。然而，它有点啰嗦:

    public interface IChildAction
    {
    }

    public class ChildAction1 : IChildAction
    {
    }

    public class ChildAction2 : IChildAction
    {
    }

    public class ChildAction3 : IChildAction
    {
    }

    public abstract class BaseRootAction
    {
        public virtual bool Process(ChildAction1 action)
        {
            return false;
        }

        public virtual bool Process(ChildAction2 action)
        {
            return false;
        }

        public virtual bool Process(ChildAction3 action)
        {
            return false;
        }
    }

    public class RootAction1 : BaseRootAction
    {
        public override bool Process(ChildAction1 action)
        {
            Console.WriteLine("Root action 1, Child action 1");
            return true;
        }

        public override bool Process(ChildAction2 action)
        {
            Console.WriteLine("Root action 1, Child action 2");
            return true;
        }
    }

    public class RootAction2 : BaseRootAction
    {
        public override bool Process(ChildAction1 action)
        {
            Console.WriteLine("Root action 2, Child action 1");
            return true;
        }

        public override bool Process(ChildAction3 action)
        {
            Console.WriteLine("Root action 2, Child action 3");
            return true;
        }
    }

    public class RootAction3 : BaseRootAction
    {
        public override bool Process(ChildAction2 action)
        {
            Console.WriteLine("Root action 3, Child action 2");
            return true;
        }
    }

    public bool DoMyThings(BaseRootAction rootAction, IChildAction childAction)
    {
        return rootAction.Process((dynamic)childAction);
    }

我还包括我的完整性测试方法:

    private void Test()
    {
        List<BaseRootAction> rootActions = new List<BaseRootAction>() { new RootAction1(), new RootAction2(), new RootAction3()};
        List<IChildAction> childActions = new List<IChildAction>() { new ChildAction1(), new ChildAction2(), new ChildAction3()};
        foreach (BaseRootAction rootAction in rootActions)
        {
            foreach (IChildAction childAction in childActions)
            {
                bool result = DoMyThings(rootAction, childAction);
                Console.WriteLine(String.Format("Processed '{0}' / '{1}': Result = {2}", rootAction.GetType().Name, childAction.GetType().Name, result));
            }
        }
    }

如果您需要枚举，可以从它们派生操作类，但解决方案会变得更加臃肿。