领域驱动设计 - 父子关系模式 - 规范模式

Question

我想知道在处理父子关系时，以下哪一项被认为是最佳做法。

1) 下面的例子看似是一种常见的做法，但是当创建一个child的实例时，只要不添加到parent中就会处于无效状态。这会不会导致验证等问题。

public class Parent
{
    private ICollection<Child> children;

    public ReadOnlyCollection Children { get; }

    public void AddChild(Child child)
    {
        child.Parent = this;
        children.Add(child);
    }
}


public class Child
{
    internal Parent Parent
    {
        get;
        set;
    }

    public Child()
    {
    }
}

2) 下一个样本将注意孩子必须始终与其父母相关。

public class Parent
{
    private ICollection<Child> children;

    public ReadOnlyCollection Children { get; }

    public Child CreateChild()
    {
        var child = new Child();
        child.Parent = this;
        children.Add(child);
        return child;
    }
}


public class Child
{
    internal Parent Parent
    {
        get;
        set;
    }

    internal Child()
    {
    }
}

3) 在最后一个例子中，孩子自己处理与父母的关系。

public class Parent
{
    private ICollection<Child> children;

    public ReadOnlyCollection Children { get; }

    public void AddChild(Child child)
    {
        child.Parent = this;
        children.Add(child);
    }
}


public class Child
{
    public Parent Parent
    {
        get;
        set;
    }

    public Child(Parent parent)
    {
        this.Parent = parent;
    }
}

哪种模式被认为是最好的？我相信模式 2 可能是最好的，因为从那时起，如果没有与父母的关系，孩子就永远无法存在。这将使其更容易，例如在实现可能执行以下操作的规范模式时：

public class ChildSpecification
{
    bool IsSatisfiedBy(Child child)
    {
        return child.Parent.Children.Where(someCondition).Count > 0;
    }
}

上述规范只有在孩子有父母的情况下才有效。

你怎么看？你知道更好的方法吗？提前致谢

Answer 1

我绝对喜欢第 2 条建议，但我认为它遗漏了第 3 条中的一些重要内容，即如果没有Parent 就不能存在Child 对象，则它应该在其构造函数中使用Parent 对象.此外，Child 类的 Parent 属性应该是只读的。 所以你最终会得到类似的东西：

public class Parent 
{ 
    private ICollection<Child> children; 

    public ReadOnlyCollection Children { get; } 

    public Child CreateChild() 
    { 
        var child = new Child(this); 
        children.Add(child); 
        return child; 
    } 
} 


public class Child 
{ 
    internal Parent Parent 
    { 
       get; 
       private set; 
    } 

    internal Child(Parent parent) 
    { 
       this.Parent = parent;
    } 
} 

Answer 2

由于我刚刚遇到相同的设计设计和问题，但仍未标记为已回答，我将发布我对解决此问题的看法 - 也许它会帮助任何人。这个解决方案实际上非常适合与 NHibernate 一起使用。

public class Parent
{
    private readonly ISet<Child> _children = new HashedSet<Child> ();
    public virtual IEnumerable<Child> Children { get { return new ImmutableSet<Child> (this._children); }  }


    protected internal virtual void AddChild (Child child)
    {
        this._children.Add(child);
    }
}


public class Child
{
    public virtual Parent Parent { get; protected set; }


    protected Child()
    {
    }


    public static Create (Parent parent)
    {
        if (parent == null)
            throw new ArgumentNullException ("parent");

        var child = new Child
        {
            Parent = parent
        };

        child.Parent.AddChild (child);

        return child;
    }
}

这与您的 #2 选项的不同之处在于，子对象的创建（并使其初始值无效）是与子对象本身一起收集的，而不是像您在 #2 中建议的那样在父对象中收集。

如果我们使用个人工厂方法 (Child.Create) 创建子对象，我不确定它是否被认为是糟糕的设计。

我希望有更多使用 DDD 经验的人对此发表评论。

Answer 3

我倾向于使用选项 (1) - 一直对我很有效。重要的是不要将 children 集合本身暴露给外界 - Parent 应该能够调解所有访问。但是我很高兴在其他地方创建一个 Child - 我只关心它被添加到 Parent 时，此时可以检查它的有效性等。

我不明白您的规范示例：如果 any 父母的孩子的 someCondition 为 true，您的 ChildSpecification 似乎会返回 true。当然，IsSatisfiedBy(Child child) 应该只在作为参数传递的特定孩子满足条件时才返回 true。