Question

我正在寻找一种简单的方法来处理我的服务器端代码中的永久状态。

我必须考虑以下几点：

状态存储在数据库中
不同的对象有不同的状态，处理方式不同

这意味着我，例如。有两种不同类型的对象Models和Parameters，每个对象都有一个状态属性，存储在我的数据库中。

当前端调用我的一个公共函数时，我需要验证给定对象的当前状态，以查看该操作是否有效。

在我的后端处理此问题的最佳方法是什么？

原创尝试

public class StateManager
{
    bool HandleState<T>(T state);
}

会像这样被称为

myStateManager.HandleState<ModelState>(GetStateFromDatabase(myModelId));

并像这样实施

bool HandleState<T>(T state)
{
   switch(T)
   {
       case ModelState:
           switch(state) 
           {
               case ModelState.Ready:
                  return true;
           }  
      case ParameterState:
          switch(state)
          {
              case ParameterState.Ready:
                  return true;
          }    
   }
}

上述解决方案不起作用，因为我无法在T上使用，因为它是枚举类型，而不是简单类型。

我正在寻找一些容易扩展的东西，既有新的状态，也有新的状态值。

Answer 1

可能的解决方案：
生成实现通用状态处理程序接口的对象的工厂，该接口接受处理枚举的T ...和x实现...

我知道的大多数ioc容器的标准内容......

通过ioc

注册状态处理程序接口的实现

致电您的工厂以获得正确的实施

即使没有ioc容器也很容易实现（如果你需要一个例子，请告诉我，以防你的googlefoo不足）

示例：

namespace playground
{
    public class Program
    {
        public static void Main()
        {
            var testcase1 = DummyStateType1.State1;
            var testcase2 = DummyStateType2.OtherState1;

            var handler1 = StateHandlerFactory<DummyStateType1>.Create();
            var handler2 = StateHandlerFactory<DummyStateType2>.Create();

            var result1 = handler1.handle(testcase1);
            var result2 = handler2.handle(testcase2);

            var alsoResult1 = tadaaaa(testcase1);
            var alsoResult2 = tadaaaa(testcase2);
        }
        static bool tadaaaa<T>(T state)
        {
            return StateHandlerFactory<T>.Create().handle(state);
        }
    }
    public interface IStateHandler<T>
    {
        bool handle(T state);
    }
    public enum DummyStateType1
    {
        State1,
        State2
    }
    public enum DummyStateType2
    {
        OtherState1,
        OtherState2
    }
    public static class StateHandlerFactory<T>
    {
        public static IStateHandler<T> Create()
        {
            //this could be replaced by IoC ... or a reflection based lookup ... you name it...
            var type = typeof(T);
            if (type == typeof(DummyStateType1))
                return (IStateHandler<T>)new DummyStateType1StateHandler();
            if (type == typeof(DummyStateType2))
                return (IStateHandler<T>)new DummyStateType2StateHandler();
            throw new NotImplementedException();
        }
    }
    public class DummyStateType1StateHandler : IStateHandler<DummyStateType1>
    {
        public bool handle(DummyStateType1 state)
        {
            switch (state)
            {
                case DummyStateType1.State1:
                    return false;
                case DummyStateType1.State2:
                    return true;
                default:
                    throw new NotImplementedException();
            }
        }
    }
    public class DummyStateType2StateHandler : IStateHandler<DummyStateType2>
    {
        public bool handle(DummyStateType2 state)
        {
            switch (state)
            {
                case DummyStateType2.OtherState1:
                    return true;
                case DummyStateType2.OtherState2:
                    return false;
                default:
                    throw new NotImplementedException();
            }
        }
    }
}

服务器端永久状态管理

1 个答案: