Understanding the Composite Pattern in C#

Introduction to the Composite Pattern

Welcome back! You have learned about the Adapter Pattern and how it helps make incompatible interfaces work together seamlessly. Now, let's dive into another crucial structural pattern that focuses on composition: the Composite Pattern . The Composite Pattern allows you to build complex structures by combining objects into tree-like structures to represent part-whole hierarchies. This pattern is particularly useful when dealing with applications like file systems, GUI frameworks, or organizational structures where you need to treat individual objects and compositions of objects uniformly.

Understanding the Composite Pattern

To understand the Composite Pattern, let's imagine an organizational tree at a tech company. Consider a tech company where you have various types of employees. At the lowest level, you have individual contributors like developers. At the mid-level, you have managers who manage these individual contributors, and at the top level, you have directors who manage multiple managers.

Hierarchical Structure Representation

In the organizational tree: Developer (Leaf Node): Developers are like leaf nodes in a tree. They perform specific, individual tasks. Manager (Composite Node): Managers are like branches. They hold and manage multiple leaves (developers) as well as other branches (lower-level managers). Director (Higher-Level Composite Node): Directors manage multiple lower-level branches (managers). Here is an example structure: Director ├── Manager A │ ├── Developer 1 │ └── Developer 2 ├── Manager B │ ├── Developer 3 │ └── Manager C │ ├── Developer 4 │ └── Developer 5 Director ├── Manager A │ ├── Developer 1 │ └── Developer 2 ├── Manager B │ ├── Developer 3 │ └── Manager C │ ├── Developer 4 │ └── Developer 5

Propagation of Function Calls

The strength of the Composite Pattern lies in its function call propagation. When a ShowDetails method is called on a director, it triggers the ShowDetails method of the managers, which in turn call the ShowDetails methods of the developers. This allows for treating individual and composite objects uniformly. Composite allows you to build complex structures by composing objects into tree-like hierarchies, making your code more robust and flexible. This approach is different from inheritance, which does not inherently facilitate part-whole hierarchies.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Director
├── Manager A
│   ├── Developer 1
│   └── Developer 2
├── Manager B
│   ├── Developer 3
│   └── Manager C
│       ├── Developer 4
│       └── Developer 5

// Define an abstract base class for Employee
abstract class Employee {
    // An abstract method to show employee details
    public abstract void ShowDetails();
}

// Define an abstract base class for Employee
abstract class Employee {
    // An abstract method to show employee details
    public abstract void ShowDetails();
}

// Define a Developer class inheriting from Employee
class Developer : Employee {
    // Properties for name and position
    public string Name { get; set; }
    public string Position { get; set; }
    
    // Constructor to initialize name and position
    public Developer(string name, string position) {
        Name = name;
        Position = position;
    }
    
    // Override method to provide developer details
    public override void ShowDetails() {
        Console.WriteLine($"{Name} works as {Position}.");
    }
}

// Define a Developer class inheriting from Employee
class Developer : Employee {
    // Properties for name and position
    public string Name { get; set; }
    public string Position { get; set; }
    
    // Constructor to initialize name and position
    public Developer(string name, string position) {
        Name = name;
        Position = position;
    }
    
    // Override method to provide developer details
    public override void ShowDetails() {
        Console.WriteLine($"{Name} works as {Position}.");
    }
}

// Define a Manager class inheriting from Employee
class Manager : Employee {
    // List to keep track of the employees managed by the manager
    private List<Employee> employees = new List<Employee>();

    // Method to add an employee to the manager's list
    public void Add(Employee employee) {
        employees.Add(employee);
    }

    // Method to remove an employee from the manager's list
    public void Remove(Employee employee) {
        employees.Remove(employee);
    }

    // Override method to provide details of all managed employees
    public override void ShowDetails() {
        foreach (var employee in employees) {
            employee.ShowDetails();
        }
    }
}

// Define a Manager class inheriting from Employee
class Manager : Employee {
    // List to keep track of the employees managed by the manager
    private List<Employee> employees = new List<Employee>();

    // Method to add an employee to the manager's list
    public void Add(Employee employee) {
        employees.Add(employee);
    }

    // Method to remove an employee from the manager's list
    public void Remove(Employee employee) {
        employees.Remove(employee);
    }

    // Override method to provide details of all managed employees
    public override void ShowDetails() {
        foreach (var employee in employees) {
            employee.ShowDetails();
        }
    }
}

class Program {
    static void Main() {
        // Create Developer instances with given names and positions
        Developer dev1 = new Developer("John Doe", "Senior Developer");
        Developer dev2 = new Developer("Jane Smith", "Junior Developer");
        
        // Create a Manager instance
        Manager manager = new Manager();
        
        // Add developers to the manager's list
        manager.Add(dev1);
        manager.Add(dev2);
        
        // Show details of all employees managed by the manager
        manager.ShowDetails();
    }
}

class Program {
    static void Main() {
        // Create Developer instances with given names and positions
        Developer dev1 = new Developer("John Doe", "Senior Developer");
        Developer dev2 = new Developer("Jane Smith", "Junior Developer");
        
        // Create a Manager instance
        Manager manager = new Manager();
        
        // Add developers to the manager's list
        manager.Add(dev1);
        manager.Add(dev2);
        
        // Show details of all employees managed by the manager
        manager.ShowDetails();
    }
}

// Define an abstract base class for Employee
abstract class Employee {
    // An abstract method to show employee details
    public abstract void ShowDetails();
}

// Define a Developer class inheriting from Employee
class Developer : Employee {
    // Properties for name and position
    public string Name { get; set; }
    public string Position { get; set; }
    
    // Constructor to initialize name and position
    public Developer(string name, string position) {
        Name = name;
        Position = position;
    }
    
    // Override method to provide developer details
    public override void ShowDetails() {
        Console.WriteLine($"{Name} works as {Position}.");
    }
}

// Define a Manager class inheriting from Employee
class Manager : Employee {
    // List to keep track of the employees managed by the manager
    private List<Employee> employees = new List<Employee>();

    // Method to add an employee to the manager's list
    public void Add(Employee employee) {
        employees.Add(employee);
    }

    // Method to remove an employee from the manager's list
    public void Remove(Employee employee) {
        employees.Remove(employee);
    }

    // Override method to provide details of all managed employees
    public override void ShowDetails() {
        foreach (var employee in employees) {
            employee.ShowDetails();
        }
    }
}

class Program {
    static void Main() {
        // Create Developer instances with given names and positions
        Developer dev1 = new Developer("John Doe", "Senior Developer");
        Developer dev2 = new Developer("Jane Smith", "Junior Developer");
        
        // Create a Manager instance
        Manager manager = new Manager();
        
        // Add developers to the manager's list
        manager.Add(dev1);
        manager.Add(dev2);
        
        // Show details of all employees managed by the manager
        manager.ShowDetails();
    }
}

Introduction to the Composite Pattern

Understanding the Composite Pattern

Hierarchical Structure Representation

Propagation of Function Calls

Join the 1M+ learners on CodeSignal

Initial Setup

Creating Individual Employees

Creating a Manager to Manage Employees

Putting it All Together

Conclusion