在其生命周期内改变聚合行为

Question

假设我们有一个具有生命周期的聚合，这样它就可以在其生命周期内改变其行为。在它生命的第一阶段，它可以做一些事情，在第二阶段，它可以做其他事情。

我想听听关于我们应该如何限制聚合在每个阶段可以执行的操作的意见。 为了使其更具体一些，让我们以金融交易为例。

• 交易者创建交易，通知合同及其价格。
• 风险经理验证交易，并说明理由。
• BackOffice 可以将交易提交到分类帐，提供会计信息。
• 交易提交后，会计信息不可更改。

交易显然有 3 个不同的阶段，我将其称为 Typed、Validated 和 Submitted

我的第一个想法是用InvalidOperationExceptions 污染聚合，我真的不喜欢：

public class Trade 
{
    private enum State { Typed, Validated, Submited }
    private State _state = State.Typed;

    public Guid Id { get; }
    public Contract Contract { get; }
    public decimal Price { get; }

    public Trade (Guid id, Contract contract, decimal price) { ... }

    private string _validationReason = null;
    private AccountingInformation _accInfo = null;

    public void Validate(string reason)  {
        if (_state != State.Typed)
            throw new InvalidOperationException (..)
        ...
        _validationReason = reason;
        _state = State.Validated;
    }

    public string GetValidationReason() {
        if (_state == State.Typed)
            throw new InvalidOperationException (..)
        return _validationReason;
    }

    public void SubmitToLedger(AccountingInformation info) {
        if ((_state != State.Validated))
            throw new InvalidOperationException (..)
        ...
    }

    public AccountingInfo GetAccountingInfo() { .. }
}

我可以执行Maybe pattern 之类的操作，以避免Get... 方法出现异常。但这不适用于行为方法（Validate、SubmitToLedger 等）

奇怪的是，如果我要使用函数式语言（例如 F#），我可能会为每个状态创建不同的类型。

type TypedTrade = { Id : Guid;  Contract: Contract; Price : decimal }

type ValidatedTrade = {  Id : Guid;  
                        Contract: Contract; 
                        Price : decimal;
                        ValidationReason : string}

type SubmittedTrade =  {  Id : Guid;  
                        Contract: Contract; 
                        Price : decimal;
                        ValidationReason : string; 
                        AccInfo : AccountingInfo }

// TypedTrade -> string -> ValidatedTrade
let validateTrade typedTrade reason = 
    ...
    { Id = typedTrade.Id; Contract = typedTrade.Contract;
            Price = typedTrade.Price; Reason = reason }

// ValidatedTrade -> AccountingInfo -> SubmittedTrade
let submitTrade validatedTrade accInfo = 
    ...
    { Id = validatedTrade.Id; 
    Contract = validatedTrade.Contract;
    Price = validatedTrade.Price; 
    Reason = validatedTrad.Reason;
    AccInfo = accInfo }

问题会优雅地消失。但要在 OO 中做到这一点，我必须使我的聚合不可变，并且可能创建某种 o 层次结构（我必须在其中隐藏基本方法！？哎呀！）。

我只是想知道你们在这些情况下的做法，以及是否有更好的方法。

Answer 1

我喜欢为每个州设置不同类型的想法。在我看来，它是一个干净的设计。从逻辑上看，新创建的交易肯定不同于提交的交易。

public Interface ITrade
{
    Guid Id { get; }
    Contract Contract { get; }
    decimal Price { get; }
}

public class Trade : ITrade
{
    public Trade(Guid id, Contract contract, decimal price)
    {
        Id = id;
        Contract = contract;
        Price = price;
    }

    Guid Id { get; }
    Contract Contract { get; }
    decimal Price { get; }

    public ValidatedTrade Validate(string reason)
    {
        return new ValidatedTrade(this, reason);
    }
}

public class ValidatedTrade : ITrade
{
    private ITrade trade;
    private string validationReason;

    public ValidatedTrade(Trade trade, string validationReason)
    {
        this.trade = trade;
        this.validationReason = validationReason;
    }

    Guid Id { get { return trade.Id; } }
    Contract Contract { get { return trade.Contract ; } }
    decimal Price { get { return trade.Price ; } }

    public string GetValidationReason()
    {
        return validationReason;
    }

    public SubmittedTrade SubmitToLedger(AccountingInfo accountingInfo)
    {
        return new SubmittedTrade(this, accountingInfo);
    }
}

public class SubmittedTrade : ITrade
{
    private ITrade trade;
    private AccountingInfo accountingInfo;

    public SubmittedTrade(ValidatedTrade trade, AccountingInfo accountingInfo)
    {
        this.trade = trade;
        this.accountingInfo = accountingInfo;
    }

    Guid Id { get { return trade.Id; } }
    Contract Contract { get { return trade.Contract ; } }
    decimal Price { get { return trade.Price ; } }

    public AccountingInfo GetAccountingInfo() { .. }
}

Answer 2

每个州可以有一个班级，而不是一个班级。请参阅 Greg Young 的这篇文章：http://codebetter.com/gregyoung/2010/03/09/state-pattern-misuse/

状态模式的常见问题是与持久性问题尤其是 ORM 之间的摩擦。由您决定是否值得为更好的健壮性和类型安全性而烦恼。