Structural Patterns in .NET Core

Structural design patterns in software development offer fundamental solutions for organizing and composing classes and objects. In the .NET Core ecosystem, three essential structural patterns stand out: Adapter, Decorator, and Facade. Let's dissect these patterns to understand their implementations and significance within the framework.

1. Adapter Pattern

The Adapter pattern serves as a bridge between incompatible interfaces, allowing them to collaborate seamlessly. It's a go-to solution when integrating existing classes into new systems or frameworks.

Implementation in .NET Core:

The key components of the Adapter pattern include the Adaptee (the existing class), the Target (the desired interface), and the Adapter itself, which bridges the gap between the Adaptee and Target interfaces.

// Adaptee: The existing class
class LegacySystem
{
    public void SpecificRequest()
    {
        Console.WriteLine("Legacy System's Specific Request");
    }
}

// Target: The interface expected by the client
interface ITarget
{
    void Request();
}

// Adapter: Adapts the Adaptee to the Target interface
class Adapter : ITarget
{
    private readonly LegacySystem _legacySystem;

    public Adapter(LegacySystem legacySystem)
    {
        _legacySystem = legacySystem;
    }

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

// Client code
class Client
{
    public void Main()
    {
        LegacySystem legacySystem = new LegacySystem();
        ITarget adapter = new Adapter(legacySystem);
        adapter.Request();
    }
}        

Use Case in .NET Core:

In scenarios where legacy systems need to be integrated into modern applications, the Adapter pattern shines. By encapsulating the legacy system's functionalities within an Adapter, it becomes compatible with the desired interfaces, ensuring smooth collaboration.

2. Decorator Pattern

The Decorator pattern facilitates the dynamic addition of responsibilities to objects without altering their structure. It ensures flexibility in extending behaviors during runtime, adhering to the open-closed principle.

Implementation in .NET Core:

In the Decorator pattern, you have a Component interface representing the base object, a ConcreteComponent as the core object, and Decorators that enhance the Component's functionalities.

// Component: Interface for objects that can be decorated
interface IComponent
{
    void Operation();
}

// Concrete Component: The basic object to be decorated
class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("Basic operation of Concrete Component");
    }
}

// Decorator: Base class for all decorators
abstract class Decorator : IComponent
{
    protected IComponent _component;

    public Decorator(IComponent component)
    {
        _component = component;
    }

    public virtual void Operation()
    {
        _component.Operation();
    }
}

// Concrete Decorator: Adds additional behavior to the component
class ConcreteDecorator : Decorator
{
    public ConcreteDecorator(IComponent component) : base(component) { }

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

// Client code
class Client
{
    public void Main()
    {
        IComponent component = new ConcreteComponent();
        component = new ConcreteDecorator(component);
        component.Operation();
    }
}        

Use Case in .NET Core:

When a system requires flexible and dynamically changeable behaviors, the Decorator pattern is valuable. For instance, in UI frameworks or data processing pipelines in .NET Core, decorators can add features like logging, caching, or encryption without modifying the core logic.

3. Facade Pattern

The Facade pattern simplifies interactions between client code and complex subsystems, providing a unified interface. It encapsulates intricate functionalities, promoting loose coupling and ease of use.

Implementation in .NET Core:

A Facade is created to interact with and hide the complexities of various subsystems, enabling a straightforward interface for clients.

// Complex subsystem
class SubsystemA
{
    public void OperationA()
    {
        Console.WriteLine("SubsystemA: OperationA");
    }
}

class SubsystemB
{
    public void OperationB()
    {
        Console.WriteLine("SubsystemB: OperationB");
    }
}

// Facade implementation
class Facade
{
    private readonly SubsystemA _subsystemA;
    private readonly SubsystemB _subsystemB;

    public Facade()
    {
        _subsystemA = new SubsystemA();
        _subsystemB = new SubsystemB();
    }

    public void Operation()
    {
        _subsystemA.OperationA();
        _subsystemB.OperationB();
    }
}

// Client code
class Client
{
    public void Main()
    {
        Facade facade = new Facade();
        facade.Operation();
    }
}        

Use Case in .NET Core:

In large-scale applications built on .NET Core, where multiple subsystems or APIs need orchestration, the Facade pattern aids in simplifying interactions. For instance, in microservices architecture, a Facade can streamline communication between different services.

Conclusion

These structural patterns, Adapter, Decorator, and Facade, empower developers in the .NET Core environment by offering elegant solutions to common design challenges. Their implementations foster code reusability, maintainability, and scalability, contributing to robust and flexible software architectures.

Summary:

This informations are basically to know the these patterns, if you want to go deeper, message me to make a deep ride article for requested pattern or you can take more search about it. I will make the articles depends on needs.