Proper way to set parent of a tree node in C#?

I'm working on a custom tree. Each node (BindingNode is how I call them) contains a BindingNodeCollection that implements ICollection and contains more nodes. My problem is that, the user should be able to access each node's parent with a readonly property called Parent, just like in a TreeNode. But the nodes are added to a BindingNodeCollection by calling BindingNodeCollection's Add(BindingNode node) method. BindingNodeCollection knows what it's own paren开发者_Python百科t is, but, can't assign BindingNode's Parent in the Add(BindingNode node) method because Parent should be readonly. The functionality I'm trying to achieve is basically the same as the functionality of a TreeNode and a TreeNodeCollection in a TreeView:

-TreeNode's Parent is readonly.

-TreeNodes are assigned to a TreeNodeCollection by calling TreeNodeCollection's Add(TreeNode node) method.

-TreeNode's Parent gives the TreeNode that contains the TreeNodeCollection where the TreeNode was added.

-TreeNodeCollection is NOT defined inside TreeNode in order to have access to the Parent private field.

This is when I miss C++'s friend. :(

There are several methods that you can achieve what you're after, it really depends on how much security you envision needing. Is this a library or a 'closed' application that only you or your colleagues will touch? Here are some suggestions and questions to consider before going with them.

1. Make the property setter on BindingNode be internal set; Do you trust everyone that is in this assembly to not orphan children?

2. Expose the BindingNodeCollection as ReadOnly and provide methods to modify the collection on the BindingNode itself. The Add can set the private Parent property. Remove will be required to set the Parent property back to null. This is pretty locked down, is polluting your base node class worth the peace of mind?

3. Accept that transparency is more important than security for you, and expose the Parent setter as public. Do you trust everyone that can see your classes not to orphan children?

For further reading and maybe better ideas, what you're almost describing is the Composite Pattern. There is a TON of discussion on security versus transparency for this pattern and most of it relates to exposing these classes for the public to consume in some API. It may be overkill for your situation, or it may be exactly what you need to consider, I have no idea given your question what the scope is.

The internal modifier is C#'s equivalent to the friend class, to make the Parent's SET method accessible only to classes within the same assembly.

TreeNode Parent { get; internal set;}

public class BindingNode
{
    private BindingNode _parent;
    private List<BindingNode> _children = new List<BindingNode>();

    public IEnumerable<BindingNode> Children
    {
        get { return _children; }
    }

    public BindingNode Parent
    {
        get { return _parent; }
    }

    public void AddChild( BindingNode node )
    {
        node._parent = this;
        _children.Add( node );
    }
}

I think it's called the decorator pattern? C'mon points if I'm right for that. I can never remember the names of patterns..

I'd make a class that is constructed in the add and at construction has the Parent property set, and just owns the node as a member. If there's an interface for BindingNode then i'd implement the interface with all the methods and properties pass throughs to the actual BindingNode.

public class BoundNode : INode
{
    private INode _thisNode { get; private set; }
    public INode Parent { get; private set; }
    public BoundNode(INode bindingNode, INode parent)
    {
        _thisNode = bindingNode;
        Parent = parent;
    }

    // Implement pass throughs to the _thisNode member

}

Then the add method would implement

public Add(INode someNode)
{
    _nodeList.Add(new BoundNode(someNode, this.Parent));
}

Or something like that.. however your collection knows about it's node context..

The proper way is to assign the child node to the parent. Like this:

parentTreeNode.Nodes.Add(childTreeNode);