CODEWITHSUNDEEP
c#oop
zsharp
zsharp

Reputation: 13756

Objects containing list of same object type

Is there anything wrong with defining something like this:

     class ObjectA
      {
         property a;
         property b;
         List <ObjectA> c;
         ...
      }

Upvotes: 4

Views: 2134

Answers (5)

mslot
mslot

Reputation: 5224

No. This is valid. Many structures uses this graph like pattern.

If you eg have a base collection class

namespace MiniGraphLibrary
{
    public class GraphCollection
    {
        public Node Root { set; get; }

        public Node FindChild(Node root)
        {
            throw new NotImplementedException();
        }

        public Node InsertNode(Node root, Node nodeToBeInserted)
        {
            throw new NotImplementedException();
        }
    }
}

Then you can have the node act like this:

namespace MiniGraphLibrary
{
    public class Node
    {
        private string _info;
        private List<Node> _children = new List<Node>();

        public Node(Node parent, string info)
        {     
            this._info = info;
            this.Parent = parent;
        }

        public Node Parent { get; set; }

        public void AddChild(Node node)
        {
            if (!this.DoesNodeContainChild(node))
            {
                node.Parent = this;
                _children.Add(node);
            }
        }

        public bool DoesNodeContainChild(Node child)
        {
            return _children.Contains(child);
        }
    }
}

Note that this is something I wrote in 2 minutes, and it is problery not good in production, but the 2 main things is that you have a parent node and many children. When you add a child node to a given node, then you make sure that it has its parent node set. Here I first check if the child is allready in the children list before connection the two. You could make some changes to the code, and make sure that if a child is removed an parent lists that it is allready connected to. I have not done this there.

I have made this to illustrate how it could be used. And it is used many places. Fx clustered indexes in MSSQL uses some sort of this tree like representation. But I am NOT an expert on this subject, so correct me if I am wrong.

I have not implemented the two classes in the GraphCollection class. The downside of my little example is that you if you are going to implement the Find method, then you have to go through the whole graph. You could make a binary tree that only has two children:

namespace MiniTreeLibrary
{
    public class SimpleNode
    {
        private string _info;
        private SimpleNode _left;
        private SimpleNode _right;
        private SimpleNode _parent;

        public SimpleNode(Node parent, string info)
        {     
            this._info = info;
            this.Parent = parent;
        }

        public Node Parent { get; private set; }
    }
}

I have omitted the insertion of the right and left. Now with this binary tree you could do some pretty darn fast searching, if you wanted!! But that is another discossion.

There is many rules when it comes trees and graphs, and my graph is even a real graph. But I have put these examples here so you can see that it is used alot!! If you want to go more into linear and other data structures, then see this serie of articles. Part 3, 4 and 5 they talks alot more about trees and graphs.

Upvotes: 1

Muad&#39;Dib
Muad&#39;Dib

Reputation: 29246

i have to ask if your question is about putting a List< > in there, or if it is about putting a List< ObjectA > inside of ObjectA. and the answer to both questions is "Yes"!

the thing to keep in mind is that by default, the access is private. if you want other classes to use this list, then you need to add a few things to your class...

class ObjectA
{
   property a;
   property b;
   List <ObjectA> c;       

   // allow access, but not assignment 
   // you can still modify the list from outside, you just cant 
   // assign a new list from outside the class
   public List<ObjectA> somePropertyName{ get { return this.c;}}

   // same as above, only allow derived child classes to set the list
   public List<ObjectA> somePropertyName{ get { return this.c;} 
                                          protected set { this.c = value;} }

   // allow all access
   public List<ObjectA> somePropertyName{ get { return this.c;} 
                                          set { this.c = value;} }


}

Upvotes: 1

phoog
phoog

Reputation: 43046

No, and because the answer needs at least 30 characters, I'll add that this is a common pattern.

Since you included the oop tag, though, I'll add that this pattern gives a lot of control to the outside world. If c is a list of children, for example, you're giving everyone who has access to an instance of ObjectA the ability to add, delete, or replace its children.

A tighter approach would be to use some sort of read-only type (perhaps implementing IList<ObjectA>) to expose the children.

EDIT

Note that the following still allows others to modify your list:

 class ObjectA 
  { 
     property a; 
     property b; 
     List <ObjectA> c; 
     ... 
     public List<ObjectA> Children { get { return c; } }
  }

The absence of a setter only prevents outsiders from replacing the list object.

Upvotes: 7

bobbymcr
bobbymcr

Reputation: 24167

It is perfectly valid. For example, you would have to do something like this to build a tree data structure (parent node contains a list of child nodes).

Upvotes: 1

Daniel A. White
Daniel A. White

Reputation: 190947

Nope. That's perfectly acceptable. Tree structures do this.

Upvotes: 6

Related Questions