Question

我有一个对象的层次结构，它们都有类似的行为。我想将行为与POCO定义分开。由于行为表示将对象移动到各种状态，因此在我看来，这似乎是状态模式的工作。但是，它并不像每个函数都有一个单一的定义那么简单，因为每个对象的行为可能略有不同。

例如，假设我有以下类，基于抽象基类：

public abstract BaseClass
{
    public int Property1 { get; set; }
    public int Property2 { get; set; }
}

public Class1 : BaseClass
{
    public string PropertyA { get; set; }
    public string PropertyB { get; set; }
}

public Class2 : BaseClass
{
    public string PropertyC { get; set; }
    public string PropertyD { get; set; }
}

层次结构表示不同类型的对象。我们还要说对象都遵循相同的基本工作流程：提交，批准，执行，关闭。

现在，每个函数的行为也是分层的，这意味着在Class1上调用函数Approve（）应该与从BaseClass调用继承行为相同，但Class2将覆盖Approve（）函数，因为该类型如下不同的审批程序。

我试图将状态模式应用于这些对象。我可以选择将函数放在对象本身上并以这种方式继承它们，这样可以正常工作，但它打破了POCO设计。我还可以使用每个对象类型的switch语句实现Approve（）函数，但这会破坏我的多态设计。

如何将状态模式应用于多层多态对象定义并与设计原则保持一致。

更新：让我澄清一下，我认为除了对该对象采取行动之外做其他事情的函数不属于POCO。例如：Approve功能将发送电子邮件并在其他系统中触发事件，而不仅仅是修改对象的状态。也许那就是我。

Answer 1

将方法放在一个对象上并不会破坏“POCO设计”（没有标准的“POCO设计”），因为POCO只是一个术语，用于对比像你所拥有的简单对象那样可以使用的更复杂或重量级的对象更大的框架。该术语通常与ORM一起用于区分简单CLR类型的对象（因此是“Plain Old CLR Objects”缩写）和从常见的特定于实现的基类型继承的对象。同样，POCO也可用于表示类型本身与使用它的ORM或库没有直接连接，因此可以很容易地与其他人一起使用。

因此，简而言之，就像您在类型上使用方法所描述的那样。

Answer 2

我可以选择将函数放在对象本身上并以这种方式继承它们，这样可以正常工作，但它打破了POCO设计

所以我同意这里的每个人不会破坏你的POCO设计。例如，它可能看起来像这样：

  public class BaseClass
  {
     public int Property1 { get; set; }
     public int Property2 { get; set; }
     public virtual bool Submitted() { return (Property1 != 0); }
     public virtual bool Approved() { return (Property2 != 0); }
     // ...
  }

  public class Class1 : BaseClass
  {
     public string PropertyA { get; set; }
     public string PropertyB { get; set; }
     public override bool Submitted() 
     { return !String.IsNullOrEmpty(PropertyA); }
     public override bool Approved() 
     // Or do specific Class1 Approval actions...
     { return !String.IsNullOrEmpty(PropertyB); }
     // ...
  }

  public class Class2 : BaseClass
  {
     public string PropertyC { get; set; }
     public string PropertyD { get; set; }
     public override bool Submitted()
     { return !String.IsNullOrEmpty(PropertyC); }
     public override bool Approved()
     { return !String.IsNullOrEmpty(PropertyD); }
     // ...
  }

  public abstract class WorkflowState<PocoType> 
     where PocoType : BaseClass
  {
     private WorkflowManager<PocoType> _workflowManger;
     private PocoType _pocoObject;

     public WorkflowManager<PocoType> Workflow
     {
        get { return _workflowManger; }
        set { _workflowManger = value; }
     }

     public PocoType PocoObject
     {
        get { return _pocoObject; }
        set { _pocoObject = value; }
     }

     public abstract void Submitted();
     public abstract void Approved();
     // ...
  }

  public class InitialState<PocoType> : 
     WorkflowState<PocoType> where PocoType : BaseClass
  {
     public InitialState(PocoType pocoObject)
     {
        base.PocoObject = pocoObject;
     }

     public override void Submitted()
     {
        if (PocoObject.Submitted())
        {
           // move to approved state if submitted is ok for the poco
           // definition
           Workflow.State = new ApprovedState<PocoType>(this);
        }
     }

     public override void Approved()
     {
        // Not supported state
        throw new InvalidOperationException();
     }

     // ...
  }

  public class ApprovedState<PocoType> :
     WorkflowState<PocoType> where PocoType : BaseClass
  {
     public ApprovedState(WorkflowState<PocoType> state)
     {
        base.PocoObject = state.PocoObject;
        base.Workflow = state.Workflow;
     }

     public override void Submitted()
     {
        // Not supported state
        throw new InvalidOperationException();
     }

     public override void Approved()
     {
        if (PocoObject.Approved())
        {
           // next state ...
           //Workflow.State = ...
           //Send emails
           //Do approval items
        }
     }
  }

  public class WorkflowManager<PocoType> where PocoType : BaseClass
  {
     WorkflowState<PocoType> _state;

     public WorkflowManager(PocoType pocoObject)
     {
        this._state = new InitialState<PocoType>(pocoObject);
        this._state.Workflow = this;
     }

     public WorkflowState<PocoType> State
     {
        get { return _state; }
        set { _state = value; }
     }

     public void RunWorkflow()
     {
        State.Submitted();
        State.Approved();
     }
  }

一些不同的运行示例可能如下所示：

Class1 test = new Class1();
test.PropertyA = "hello";
WorkflowManager<Class1> work_flow_man = new WorkflowManager<Class1>(test);
work_flow_man.RunWorkflow();

Class2 test2 = new Class2();
test2.PropertyC = "cool";
test2.PropertyD = "dude";
WorkflowManager<Class2> work_flow_man2 = new WorkflowManager<Class2>(test2);
work_flow_man2.RunWorkflow();

Answer 3

只是为了让您了解如何集中定义状态之间转换的代码I cracked my brain a long time ago on the state pattern。当时仿制药很新，所以它有点沉重。无论哪种方式，它可能会为您提供有关如何实现状态模式的另一个视角。

具有多态对象的状态设计模式

3 个答案: