How to include properties via composition?

Question

After having to refactor the inheritance chain in my current project for the third time I googled "Inheritance sucks" and found that the problem I'm having is not uncommon and composition is a recommended alternative solution.

I understand how you can use composition to add behavior in form of functions, but I'm having problems to come up with ways to add properties by the same means.

Let's say I want to model tree nodes. Every node has at least two properties: name and description.

class Node {
   public string Name { get; set; }
   public string Description { get; set; }
}

Other more specific nodes would inherit those properties, like so:

class StructuredNode : Node {
   public List<Node> Children { get; set; }
}

How could I achieve similar re-usability of the property code without relying on inheritance and the problems that come with it?
Is there a design pattern for this or do I have to use inheritance in such a case?

Thanks in advance!

Edit: Examples for the position "composition over inheritance":

• ScottLilly
• Wikipedia
• Codingdelight

Answer 1

Rather then depending on class , you should depend son abstraction (this also one part of making use of composition) so for you case you should do like this

public interface INode {
   string Name { get; set; }
   string Description { get; set; }
}

class Node : INode {
   public string Name { get; set; }
   public string Description { get; set; }
}

class StructuredNode : INode {
   public string Name { get; set; }
   public string Description { get; set; }
   public List<INode> Children { get; set; }
}

or you can also do this

//this is something similar to decorator pattern.
class StructuredNode  {
   private readonly INode _node;
   public StructureNode(INode node)
   {
      _node = node;//now you can reuse function of any class which implements INode
   }

   public List<INode> Children { get; set; }
}

you should do like this also later on

   List<Node> nodes = List<Node>();
   StructuredNode sNode = new StructuredNode();
   sNode.Children  = nodes; 

this is possible as all is based on abstraction. and all implementation now make use of INode

or

other solution suggested you in comment is make use of Decorator pattern. If you just want to extend you class without modifying it.