有时候常量比枚举好用

有这样一个场景，有下面的Logic类，每个类中都需要判断DoOperAction是否为空，然后进行一些操作。由于每个Logic对应的OperType可能不一致，因此就每个类定义了特定的判断方法。但当Logic类增加时，DoOper方法又需要重新定义一次，觉得得重构下。应该可以提取到BaseLogic中。


第一次提取，由于每个Logic中OperType的不一致，提取后，只能使用枚举类型的兼容类型int，具体代码如下：

    public abstract class BaseLogic
    {
        public Action<int> DoOperAction;

        protected void DoOper(int a)
        {
            //some complex logic
            if (null != DoOperAction)
            {
                var action = DoOperAction;
                action(a);
            }
        }
    }

   public class ConcreteLogicA : BaseLogic
    {
        public enum OperType
        {
            MoveA,
            DragA
        }

        public void DoDrag()
        {
            DoOper((int) OperType.DragA);
        }

        public void DoMove()
        {
            DoOper((int) OperType.MoveA);
        }
    }

看起来还不错，但是。。。当OperType中的类型变多时，每次填写DoOper的参数时就需要强制转换，那么怎么解决？ 将枚举替换为常量。
代码如下：

    public class ConcreteLogicA : BaseLogic
    {
        public sealed class OperType
        {
            public const int MoveA = 1;
            public const int DragA = 2;
        }

        public void DoDrag()
        {
            DoOper(OperType.DragA);
        }

        public void DoMove()
        {
            DoOper(OperType.MoveA);
        }
    }

综上，有时常量比枚举好用。