Structural patterns (e.g. Adapter, Decorator, Facade) in C#

Structural patterns are design patterns that provide a way to organize objects and classes in a flexible and reusable way. In C#, there are several common structural patterns that you can use to organize your code, including Adapter, Decorator, and Facade.

Here’s an overview of each of these patterns and how to use them in C#:

1. Adapter: The Adapter pattern is a structural pattern that allows you to adapt an existing class to a new interface without changing the existing class. This can be useful when you have an existing class that you want to use in a new context, but the new context requires a different interface. Here’s an example of an Adapter in C#:

public interface ITarget
{
    void Request();
}

public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Adaptee Specific Request");
    }
}

public class Adapter : ITarget
{
    private Adaptee adaptee = new Adaptee();

    public void Request()
    {
        adaptee.SpecificRequest();
    }
}

In this example, the `ITarget` interface defines the new interface that we want to use, and the `Adaptee` class defines the existing class that we want to adapt. The `Adapter` class implements the `ITarget` interface and uses an instance of the `Adaptee` class to implement the `Request` method.

2. Decorator: The Decorator pattern is a structuralpattern that allows you to add behavior to an object dynamically, without changing its interface. This can be useful when you want to add new functionality to an object without modifying its existing behavior. Here’s an example of a Decorator in C#:

public interface IComponent
{
    void Operation();
}

public class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("Concrete Component Operation");
    }
}

public abstract class Decorator : IComponent
{
    private IComponent component;

    public Decorator(IComponent component)
    {
        this.component = component;
    }

    public void Operation()
    {
        component.Operation();
    }
}

public class ConcreteDecorator : Decorator
{
    public ConcreteDecorator(IComponent component) : base(component)
    {
    }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("Concrete Decorator Operation");
    }
}

In this example, the `IComponent` interface defines the interface for the component that we want to decorate, and the `ConcreteComponent` class defines the concrete implementation of that component. The `Decorator` class is an abstract class that implements the `IComponent` interface and provides a way to add behavior to the component. The `ConcreteDecorator` class extends the `Decorator` class and adds new behavior to the component.

3. Facade: The Facade pattern is a structural pattern that provides a simplified interface to a complex system. This can be usefulwhen you have a complex system with many components and you want to provide a simple interface for clients to interact with. Here’s an example of a Facade in C#:

public class SubsystemA
{
    public void OperationA()
    {
        Console.WriteLine("Subsystem A Operation");
    }
}

public class SubsystemB
{
    public void OperationB()
    {
        Console.WriteLine("Subsystem B Operation");
    }
}

public class Facade
{
    private SubsystemA subsystemA = new SubsystemA();
    private SubsystemB subsystemB = new SubsystemB();

    public void Operation()
    {
        subsystemA.OperationA();
        subsystemB.OperationB();
    }
}

In this example, the `SubsystemA` and `SubsystemB` classes define the complex system that we want to simplify. The `Facade` class provides a simple interface to the system by encapsulating the complexity of the subsystems and exposing a single `Operation` method that clients can use to interact with the system.

Overall, Adapter, Decorator, and Facade are all powerful and flexible structural patterns that can be used to organize your code in a flexible and maintainable way. Each pattern has its own strengths and weaknesses, so it’s important to choose the one that best fits your needs. Whatever pattern you choose, structural patterns are an important part of design patterns that can help you to organize your code in a flexible and maintainable way.