I would say you are looking for the Composite pattern: http://en.wikipedia.org/wiki/Composite_pattern[^]. With this pattern the quick solution is to make class A the composite and class B an component. A more beautiful solution is to create an abstract Component class that just contains the functionality related to administering the tree data structure. You then create 2 implementations of this abstract class: - class B that just re-uses the methods of the abstract class and adds its own functionality, - class A that just re-uses the methods of the abstract class, but adds collection functionality and its own functionality. A very beautiful solution is to separate specification from implementation: - specify B's own functionality in an interface IB, - specify A's own functionality in an interface IA, - make an abstract class Component that contains child logic, - make an abstract class Composite that contains collection logic, - make a class B that inherits class Component and implements IB, - make a class A that inherits class Composite and implements IA. In the implementation of class B, you can now check, if the parent is of type IA, and then use the functionality of IA. In the implementation of class A, you can now check, if a child is of type IB, and then use the functionality of IB. You can even make interfaces for the Component and the Composite, if you go 100%. Hope above was a little helpful. Remember, you decide your design! Regards, Keld Ølykke