自动在子项上设置父引用

Question

I have a class that contains an IList<T> property called Children . Each child should reference its parent. My solution has been to set the ChildClass.Parent property in the ParentClass.Children getter. Is there a better way, or is this the best solution?

class ParentClass
{
    private IList<ChildClass> _children;

    public virtual IList<ChildClass> Children
    {
        get
        {
            // make sure each child refers to its parent (this)
            foreach (ChildClass c in _children)
            {
                c.Parent = c.Parent ?? this;
            }
            return _children;
        }
        set
        {
            _children = value;
        }
    }
}

Answer 1

It could just be me...but this looks like a bad design.

If it's a true Parent -> Child relationship, you shouldn't allow anybody to create an Orphan Child. Therefore, the Parent should be set on the Child at the time of creation.

I would probably do something like:

class ChildClass
{
    private ParentClass _parent;

    public ChildClass(ParentClass parent)
    {
        _parent = parent;
    }
}

And then:

class ParentClass
{
    private List<ChildClass> _children;

    public virtual ReadOnlyCollection<ChildClass> Children
    {
        get
        {
            return _children.AsReadOnly();
        }
    }

    public virtual ChildClass CreateChild()
    {
        // Set parent in child class constructor
        ChildClass newChild = new ChildClass(this);

        _children.Add(newChild);

        return newChild;
    }
}

Answer 2

The problem with your solution is that if all the children and parents are correctly linked, your code will re-link them each time the internal child collection is retrieved. Also, it seems that this problem exists because you are returning a reference to a private collection, after which you lose control of the elements it contains.

I suggest the following:

Provide Add(ChildCLass) and Remove(ChildClass) methods on ParentClass , and enforce the parent-child constraint there. This allows children to be created anywhere, and be linked correctly when belonging to the hierarchy. When the are removed from the hierarchy, the are no longer linked.

Do not return a reference to your internal ChildClass collection unless the collection is immutable. Returning a ReadOnlyCollection or IEnumerable is preferable.

Examples:

class ChildClass
{
    // Prevent unauthorized clients from overriding the Parent reference.
    public ParentClass Parent { get; internal set; }

    // ... other methods and properties ...
}

class ParentClass
{
    private IList<ChildClass> _children;

    public void AddChild(ChildClass child)
    {
        _children.Add(child);
        child.Parent = this;
    }

    public RemoveChild(ChildClass child)
    {
        _children.Remove(child);
        child.Parent = null;
    }

    public IList<ChildClass> Children
    {
        get { return _children.AsReadOnly(); }
    }
}