枚举组合的设计模式（方法参数）

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;
     }

但是，我确实认为这是一段难看的代码...:) ...此服务的 "consumer" 不知道 root/child 的正确组合是有效并可能通过错误的。

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

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

也许我只是从一个角度来看这个，不知何故我无法扩大自己的视野...所以我想听听您的一些反馈guys/gals...

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

谢谢。

Answer 1

第一步可能是在每种情况下调用一个方法。

case EnumRootAction.Type1:
    switch(child){
        case EnumChildAction.Ac1: 
            Type1_Ac1();
            break;

第二步可能是使用委托矩阵而不是函数。

    delegate bool DoMyThingsAction();
    DoMyThingsAction[,] doMyThings;

    public void InitializeDoMyThings()
    {
        doMyThings = new DoMyThingsAction[10, 10]; // number of actions and type
        doMyThings[0, 0] = Type1_Ac1;
        // and so on
    }

要调用它，您可以使用

    doMyThings[(int)root, (int)child];

如果您不喜欢在 doMyThings 调用中转换为 int，您可以使用不同的结构并覆盖索引器。

还有一种方法是使用反射获取方法（我不喜欢）

public bool DoMyThings(EnumRootAction root, EnumChildAction child){
       return GetType().GetMethod(string.Format("{0}_{1}", root, child).Invoke(this);
}

编辑
查看您的程序，如果没有该方法，您应该 return false 。如果是矩阵，你可以在调用它之前检查是否有函数，如果是反射，你可以检查 GetMethod returns null.

Answer 2

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

    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));
            }
        }
    }

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

Answer 3

您可以应用访问者模式。您的 RootAction 是访客，ChildAction 是元素。这是代码，注意 OOP 中的重载有多强大：

List<RootAction_Visitor> visitors = new List<>();
visitors[EnumRootAction.Type1] = new RootAction1_Visitor();
visitors[EnumRootAction.Type2] = new RootAction2_Visitor();

List<ChildAction_Element> elements = new List<>();
elements[EnumChildAction.Ac1] = new ChildAction1_Element();
elements[EnumChildAction.Ac2] = new ChildAction2_Element();
elements[EnumChildAction.Ac3] = new ChildAction3_Element();

public void doMyThing(EnumRootAction root, EnumChildAction child) {
    elements[child].accept( visitors[root] );
}

//=======================================================================
// Visitors

abstract class RootAction_Visitor {
    public void visit(ChildAction1_Element childAction) { /*.. reject by default ...*/ }
    public void visit(ChildAction2_Element childAction) { /*.. reject by default ...*/ }
    public void visit(ChildAction3_Element childAction) { /*.. reject by default ...*/ }
}

class RootAction1_Visitor : RootAction_Visitor {
    public override void visit(ChildAction1_Element childAction) {
        // ... do something
    }
    public override void visit(ChildAction2_Element childAction) {
        // ... do something
    }
}

class RootAction2_Visitor : RootAction_Visitor {
    public override void visit(ChildAction1_Element childAction1) {
        // ... do something
    }
    public override void visit(ChildAction3_Element childAction3) {
        // ... do something
    }
}

//=======================================================================
// Elements

interface ChildAction_Element {
    void accept(RootAction_Visitor visitor);
}

class ChildAction1_Element : ChildAction_Element {
    public void accept(RootAction_Visitor visitor) { visitor.visit(this); }
}

class ChildAction2_Element : ChildAction_Element {
    public void accept(RootAction_Visitor visitor) { visitor.visit(this); }
}

class ChildAction3_Element : ChildAction_Element {
    public void accept(RootAction_Visitor visitor) { visitor.visit(this); }
}

因为你的客户端和服务器通过网络进行通信（进程间通信）。没有办法确保客户端发送的数据是有效的，我们需要验证数据并拒绝错误的请求。但是，您应该提供另一项服务，以便客户在请求您的主要服务之前可以知道哪些操作组合是正确的。

P/S：选择RootAction和ChildAction，哪个是Visitor，哪个是Element，看他们的稳定性。如果 RootAction 不稳定，即新的 RootAction 会出现，那么它们应该是 Visitors.

枚举组合的设计模式（方法参数）

Design pattern for enum combination (method parameters)

c#

enums

design-patterns