如何在类中交叉引用对象

好问题。纯粹的多对多关系实际上非常罕见,通常引入一个中间对象来对关系本身建模会有帮助。如果(当!)出现了需要捕获关系属性的用例(例如,子/父关系是否是自然的、代理的、收养的等)。

所以,除了已经标识的人、父实体和子实体之外,让我们引入一个名为parentchildrelationship的对象。 parentchildrelationship的实例将只引用一个父类和一个子类,父类和子类都将包含这些实体的集合。

然后,最好确定使用这些实体的用例,并添加适当的帮助器方法来维护对象间引用。 在下面的示例中,我刚刚选择将public addchild方法添加到父方法。

public abstract class Person
{
}

public class Parent : Person
{
    private HashSet<ParentChildRelationship> _children = 
        new HashSet<ParentChildRelationship>();

    public virtual IEnumerable<ParentChildRelationship> Children
    {
        get { return this._children; }
    }

    public virtual void AddChild(Child child, RelationshipKind relationshipKind)
    {
        var relationship = new ParentChildRelationship()
        {
            Parent = this,
            Child = child,
            RelationshipKind = relationshipKind
        };

        this._children.Add(relationship);
        child.AddParent(relationship);
    }
}

public class Child : Person
{
    private HashSet<ParentChildRelationship> _parents = 
        new HashSet<ParentChildRelationship>();

    public virtual IEnumerable<ParentChildRelationship> Parents
    {
        get { return this._parents; }
    }

    internal virtual void AddParent(ParentChildRelationship relationship)
    {
        this._parents.Add(relationship);
    }
}

public class ParentChildRelationship
{
    public virtual Parent Parent { get; protected internal set; }

    public virtual Child Child { get; protected internal set; }

    public virtual RelationshipKind RelationshipKind { get; set; }
}

public enum RelationshipKind
{
    Unknown,
    Natural,
    Adoptive,
    Surrogate,
    StepParent
}

public class Person
{
    Person Parent { get;set; }
    IList<Person> Children { get;set; }
}

当您不知道父级时,父级可以为空。 没有子项时,子项可以为空。 因为每个孩子都是一个人,所以它可以有父母或自己的孩子。

在您提供关于如何使用或持久化它的更详细的用例场景之前,这个设计本身是很好的。

如果你能限制协会的发展方向 单程 ,你会省去很多麻烦(但这并不总是可能的)。

单向关系:

public class Parent : Person
{
    public IEnumerable<Person> Children { get; }
}

如果你想让协会也朝另一个方向发展,你也可以这样做:

public class Child : Person
{
    public Parent Parent { get; }
}

但是,现在您有一个需要维护的循环引用,虽然这是可能的,但它并不是特别有效。

你可以通过让孩子们 提高事件 而不是显式地引用它们的父对象。

正如johnidol所指出的那样,一个孩子在某种程度上可能成为父母。换言之,不要把父母和孩子划分为人的子类。

class Person
{
   readonly List<Person> _children = new List<Person>(), 
                         _parents = new List<Person>();

   public IEnumerable<Person> Children 
   { 
      get { return _children.AsReadOnly(); } 
   }

   public IEnumerable<Person> Parents 
   { 
      get { return _parents.AsReadOnly(); } 
   }

   public void AddChild(Person child)
   {
       _children.Add(child);
       child._parents.Add(this);
   }

   public void AddParent(Person parent)
   {
       _parents.Add(parent);
       parent._children.Add(this);
   }

   /* And so on... */
}

我可以想象一个孩子也可以成为一个家长(如果他幸运的话…或者不走运,这取决于观点),所以我会说:

IPerson
{
   string Name {get; set;}
   string LastName {get; set;}
   // whatever else - such as sizeOfShoe, dob, etc
}

IHaveParents
{
   // might wanna limit this to a fixed size
   List<IPerson> Parents {get; set;}
}

IHaveChildren
{
   List<IPerson> Children {get; set;}
}

IHaveSpouse
{
   IPerson Spouse {get; set;}
}

public class DudeWithParentsAndChildren : IPerson, IHaveParents, IHaveChildren, IHaveSpouse
{       
   public void AskMoneyToParents(){throw new Exception("Implement me!");}
   public void SlapChildren(){}
   private void CheatOnSpouse(){}
   // some other stuff that such a dude can do i.e. GoBowling
}

当新的需求出现时(相信我他们会的),你可以很容易地以任何方式扩展它。

更新 : 因此,如果你只想让孩子有父母,而另一方面,你会做如下事情:

public class Child : IPerson, IHaveParents
{       
   public void AskMoneyToParents(){throw new Exception("Implement me!");}
}

public class Parent : IPerson, IHaveChildren, IHaveSpouse
{       
   public void SlapChildren(){}
   private void CheatOnSpouse(){}
   // some other stuff that such a dude can do i.e. GoBowling
}

这样,如果您想要一个iHaveFriends接口,就可以(这基本上迫使实现者将iperson列表公开为名为friends的属性)。如果你不需要它,就不要这样做,但事实上,你可以很容易地做到,只需添加一个接口,其他一切都保持不变,这意味着你有一个相当不错的可扩展模型(不一定是最好的,你知道我的意思)。