'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 parent 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. :(

c++sharp


Solution 1:[1]

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;}

Solution 2:[2]

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 );
    }
}

Solution 3:[3]

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..

Solution 4:[4]

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

parentTreeNode.Nodes.Add(childTreeNode);

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1
Solution 2
Solution 3
Solution 4 Joost B.

Related Questions