服务器端永久状态管理

Question

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

有几件事我必须考虑：

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

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

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

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

原始尝试

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

服务器端永久状态管理

Server-side permanent state management

c#

asp.net

state

backend

switch-statement