1

我有一个对象层次结构，它们都具有相似的行为。我想将行为与 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 函数将发送电子邮件并触发其他系统中的事件，而不仅仅是修改对象的状态。也许这只是我。

4

3 回答 3

1

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

所以，简而言之，就像你用类型上的方法描述的那样做。

于 2011-10-27T12:48:44.180 回答
1

我可以选择将函数放在对象本身上并以这种方式继承它们，效果很好，但它破坏了 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();
于 2011-10-27T14:10:34.433 回答
0

只是为了让您了解如何集中定义状态之间转换的代码，我很久以前就对状态模式进行了研究。那时泛型还很新，所以它有点沉重。无论哪种方式，它都可以让您从另一个角度了解如何实现状态模式。

于 2011-10-27T12:42:16.833 回答