Composite Pattern

Greetings, fellow developers! Welcome back to Dot Net Core Central. Today, we delve into the fascinating realm of design patterns, focusing our attention on the Composite Design Pattern—a structural gem from the illustrious Gang of Four design patterns.

Unveiling the Power of Composite Pattern

The Composite Design Pattern, nestled within the category of structural design patterns, offers a robust solution to the challenges of hierarchical object representation. Its primary intent is to compose objects into tree structures, forming part-whole hierarchies. This architectural approach enables clients to treat individual objects and compositions of objects uniformly, creating a seamless experience.

Navigating Hierarchical Object Structures

In the world of software development, dealing with hierarchical objects is inevitable. Picture a hierarchy composed of nodes and leaves, with a base or root node initiating the structure. This recursive composition, akin to a folder structure in a PC, forms the basis of the Composite Design Pattern.

A significant challenge arises in establishing a uniform structure or contract between leaves and nodes. Herein lies the essence of the pattern: enabling clients to treat individual objects and compositions uniformly. However, it’s crucial to acknowledge a shortcoming—we’ll explore this in detail as we dive into the implementation.

Crafting the Composite Design Pattern

To illustrate the power of the Composite Design Pattern, let’s create a class hierarchy representing an object structure. Our hierarchy comprises composite nodes and leaf nodes, emulating a tree structure.

The journey begins with the definition of an abstract base class, Node, featuring essential methods for adding and removing nodes, printing children, and printing parents. This base class forms the blueprint for both composite and leaf nodes.

namespace CompositePattern.Demo;

internal abstract class Node
{
    public abstract string Name { get; }

    public virtual void Add(Node node) =>
        throw new NotImplementedException();

    public virtual void Remove(Node node) =>
        throw new NotImplementedException();

    public virtual void PrintChildren() =>
        throw new NotImplementedException();

    public virtual void PrintParent() =>
        throw new NotImplementedException();
}

Implementing Composite Nodes

The first class we craft is the CompositeNode, inheriting from the Node base class. The CompositeNode allows the addition and removal of child nodes, printing children, and printing the parent. It seamlessly embraces the hierarchical structure.

namespace CompositePattern.Demo;

internal class CompositeNode : Node
{
    private List<Node> children = new();
    private readonly string name;
    private readonly Node? parentNode;

    public override string Name => name;

    public CompositeNode(string name, Node? parentNode = null)
    {
        this.name = name;
        this.parentNode = parentNode;
    }

    public override void Add(Node node)
    {
        children.Add(node);
    }

    public override void Remove(Node node)
    {
        children.Remove(node);
    }

    public override void PrintParent()
    {
        if (parentNode != null)
            Console.WriteLine($"Parent: {parentNode.Name}");
        else
            Console.WriteLine("Root node");
    }

    public override void PrintChildren()
    {
        Console.WriteLine
            ($"Children: {string.Join(',', children.Select(c => c.Name))}");
    }
}

Embracing Leaf Nodes

The LeafNode class, another offspring of the Node base class represents the leaf nodes in our hierarchy. With a mandatory parent node, the LeafNode focus is on printing the parent and adhering to the uniform contract.

namespace CompositePattern.Demo;

internal class LeafNode : Node
{
    private readonly string name;
    private readonly Node parentNode;

    public override string Name => name;

    public LeafNode(string name, Node parentNode)
    {
        this.name = name;
        this.parentNode = parentNode;
    }

    public override void PrintParent()
    {
        Console.WriteLine($"Parent: {parentNode.Name}");
    }
}

Building and Testing the Hierarchy

In the program class, we construct a hierarchical structure, including a root node, composite nodes, and leaf nodes. With carefully orchestrated additions and removals, we showcase the behavior of the Composite Design Pattern in action. The output elegantly demonstrates the hierarchical relationships, validating the effectiveness of the pattern.

using CompositePattern.Demo;

var root = new CompositeNode("Root");

var node1 = new CompositeNode("node1", root);
var leaf11 = new LeafNode("leaf11", node1);
var leaf12 = new LeafNode("leaf12", node1);
node1.Add(leaf11);
node1.Add(leaf12);

var node2 = new CompositeNode("node2", root);
var leaf1 = new LeafNode("leaf1", root);

root.Add(leaf1);
root.Add(node1);
root.Add(node2);

Console.WriteLine("Root ======");
root.PrintParent();
root.PrintChildren();

Console.WriteLine("leaf1 ======");
leaf1.PrintParent();

Console.WriteLine("node1 ======");
node1.PrintParent();
node1.PrintChildren();

Console.WriteLine("leaf11 ======");
leaf11.PrintParent();
leaf11.PrintChildren();

Unpacking the Shortcomings

While the Composite Design Pattern provides an elegant solution, it introduces a challenge. The uniform contract, while beneficial, leads to a potential inconsistency. For instance, the PrintChildren method is valid for composite nodes but invalid for leaf nodes. Striking a balance between uniformity and tailored behavior is a nuanced consideration in implementing this pattern.

Conclusion: Harnessing the Composite Design Pattern

In the tapestry of design patterns, the Composite Design Pattern stands as a versatile tool for managing hierarchical structures. While its uniform contract may present challenges, the benefits in terms of code organization and flexibility are undeniable.

And with that, we conclude our exploration of the Composite Design Pattern in .NET Core. If this journey resonated with you, don’t forget to go through the rest of my blog posts.

For more coding revelations and design pattern insights, consider visiting my YouTube channel and subscribing to .Net Core Central. Until next time, happy coding!