Design Patterns

Design patterns are reusable solutions to common software design problems. They provide a way to organize and structure code in a consistent and maintainable way. In C#, there are several design patterns that are commonly used to solve a variety of problems in object-oriented programming. These patterns can be divided into three main categories: creational, structural, and behavioral.

1. Creational Design Patterns: These patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. It deals with object creation, trying to create objects in a manner suitable to the situation. Some of the Creational Design patterns in C# are:

• Singleton pattern: This pattern ensures that a class has only one instance, while providing a global access point to this instance.
• Factory pattern: This pattern provides an interface for creating objects in a super class, but allows subclasses to alter the type of objects that will be created.
• Abstract Factory pattern: This pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

2. Structural Design Patterns: These patterns deal with object composition. They use inheritance and composition to form large structures from small individual objects. Some of the Structural Design patterns in C# are:

• Adapter pattern: This pattern allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class.
• Bridge pattern: This pattern separates an object’s interface from its implementation so you can vary or replace the implementation without changing the client code.
• Composite pattern: This pattern allows you to compose objects into tree structures to represent part-whole hierarchies.
• Decorator pattern: This pattern allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class.
• Facade pattern: This pattern provides a simplified interface to a complex system of classes.

3. Behavioral Design Patterns: These patterns deal with communication between objects. They describe how objects can operate together to carry out the flow of a program. Some of the Behavioral Design patterns in C# are:

• Chain of Responsibility pattern: This pattern allows multiple objects to handle a request, with the order of objects defined at runtime.
• Command pattern: This pattern encapsulates a request as an object, allowing for different requests to be handled using the same interface.
• Iterator pattern: This pattern allows for the traversal of a collection of objects without exposing its underlying representation.
• Mediator pattern: This pattern allows objects to communicate without knowing each other’s identities.
• Observer pattern: This pattern allows for objects to be notified of changes to other objects, without the objects being tightly coupled.
• State pattern: This pattern allows an object to alter its behavior when its internal state changes.
• Strategy pattern: This pattern allows for the selection of an algorithm at runtime.
• Template Method pattern: This pattern defines the skeleton of an algorithm in a method, allowing subclasses to fill in the details.
• Visitor pattern: This pattern allows for the operation to be performed on a set of objects from a collection, without changing the classes of the objects themselves.

It’s worth noting that these patterns is not a definitive solution for the specific problem, it just provides a common approach to solve the problem, you should evaluate and make a decision whether the pattern is a good fit for your specific use case. Also it’s very important to keep in mind that over-using design patterns can lead to a more complex and harder-to-maintain codebase.

Singleton pattern

The Singleton pattern is a creational design pattern that ensures a class has only one instance, while providing a global access point to this instance. The singleton class has a private constructor to prevent other objects from instantiating it, and it keeps a static reference to its sole instance. Here’s an example of a simple implementation of the Singleton pattern in C#:

public sealed class Singleton
{
    private static Singleton instance = null;
    private static readonly object padlock = new object();

    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}

This implementation uses the Lazy Initialization approach, which means that the instance is not created until the first time it is accessed. The Instance property uses a lock statement to ensure that only one thread can create the instance at a time, making it thread-safe.

The sealed keyword is used on the class definition to prevent inheritance, allowing a derived class to circumvent the singleton pattern.

Here’s an example of how to use the Singleton class:

Singleton singleton1 = Singleton.Instance;
Singleton singleton2 = Singleton.Instance;

Console.WriteLine(singleton1.GetHashCode());
Console.WriteLine(singleton2.GetHashCode());

Output:-

12345678
12345678

In this example, singleton1 and singleton2 are references to the same instance of the Singleton class, and their hash codes are the same.

Note that there’re other implementation of singleton like using static constructors, this is just one example, also it’s also important to consider if a singleton is really a good fit for your use case as it can cause tight coupling, it can make testing hard and some design pattern suggest to avoid using it.

Factory pattern

The Factory pattern is a creational design pattern that provides an interface for creating objects in a super class, but allows subclasses to alter the type of objects that will be created. This pattern allows to encapsulate the instantiation process and provide a way to create objects of different types, without specifying the exact class of object that will be created.

Here’s an example of a simple implementation of the Factory pattern in C#:

public interface IProduct
{
    string Description();
}

public class ProductA : IProduct
{
    public string Description()
    {
        return "I am Product A";
    }
}

public class ProductB : IProduct
{
    public string Description()
    {
        return "I am Product B";
    }
}

public class Factory
{
    public IProduct GetProduct(string productType)
    {
        if (productType == "A")
        {
            return new ProductA();
        }
        else if (productType == "B")
        {
            return new ProductB();
        }
        return null;
    }
}

In this example, we have an interface IProduct that defines a method Description(), and two classes ProductA and ProductB that implement that interface. The Factory class has a method GetProduct that takes a string argument specifying the type of product to be created, and it returns an object of the specified type.

Here’s an example of how to use the Factory class:

Factory factory = new Factory();

IProduct productA = factory.GetProduct("A");
Console.WriteLine(productA.Description());

IProduct productB = factory.GetProduct("B");
Console.WriteLine(productB.Description());

Output:

I am Product A
I am Product B

In this example, the GetProduct method is called twice, once with the argument “A” and once with the argument “B”. The factory creates an instance of ProductA and ProductB respectively and the output is what is expected.

The factory pattern is a good way to create objects when you want to centralize control over the creation process and you want to hide the instantiation logic from the client. It provides a way to change the type of objects that are created without changing the code that calls the factory method. Also you can use more advanced version like abstract factory pattern, it allows to create families of related or dependent objects without specifying their concrete classes.

Abstract Factory pattern

The Abstract Factory pattern is a creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes. This pattern allows you to create objects that belong to a particular class hierarchy, and it provides a way to change the implementation of that hierarchy without changing the code that uses it.

Here’s an example of a simple implementation of the Abstract Factory pattern in C#:

public abstract class Vehicle
{
    public abstract string Description();
}

public class Car : Vehicle
{
    public override string Description()
    {
        return "I am a Car";
    }
}

public class Bike : Vehicle
{
    public override string Description()
    {
        return "I am a Bike";
    }
}

public abstract class VehicleFactory
{
    public abstract Vehicle CreateVehicle();
}

public class CarFactory : VehicleFactory
{
    public override Vehicle CreateVehicle()
    {
        return new Car();
    }
}

public class BikeFactory : VehicleFactory
{
    public override Vehicle CreateVehicle()
    {
        return new Bike();
    }
}

In this example, Vehicle is an abstract class that defines the interface for creating Vehicle objects. Car and Bike are concrete classes that implement this interface. VehicleFactory is an abstract class that defines the interface for creating VehicleFactory objects. CarFactory and BikeFactory are concrete classes that implement this interface and create the desired objects of Car and Bike respectively.

Here’s an example of how to use the Abstract Factory:

VehicleFactory factory;

if (condition)
    factory = new CarFactory();
else
    factory = new BikeFactory();

Vehicle vehicle = factory.CreateVehicle();
Console.WriteLine(vehicle.Description());

In this example, a factory object is created based on a given condition, and the factory is used to create a Vehicle object. The CreateVehicle method creates an instance of the appropriate class, either Car or Bike, and the output is the description of the created object.

The Abstract Factory pattern allows you to create families of related objects without specifying their concrete classes. It provides a way to change the implementation of a class hierarchy without changing the code that uses it. It is also useful when you want to centralize the control over the creation of objects and hide the instantiation logic from the client.

It’s worth noting that, just as with the Factory pattern, it’s important to evaluate if the Abstract Factory pattern is the best fit for your specific use case and not to overuse it.

Prototype pattern

The Prototype pattern is a creational design pattern that allows you to create new objects by cloning existing objects, rather than by creating them from scratch. This pattern is useful when creating new objects is an expensive or complex operation and you want to avoid the overhead of creating new objects from scratch every time.

Here’s an example of a simple implementation of the Prototype pattern in C#:

public interface IPrototype<T>
{
    T Clone();
}

public class ConcretePrototype : IPrototype<ConcretePrototype>
{
    public string Name { get; set; }
    public ConcretePrototype Clone()
    {
        return (ConcretePrototype)this.MemberwiseClone();
    }
}

In this example, IPrototype is an interface that defines a single method Clone(). The ConcretePrototype class is a concrete implementation of this interface. This class has a Name property, and the Clone() method creates a new object that is a copy of the current object, using the MemberwiseClone() method to create a shallow copy of the object.

Here’s an example of how to use the Prototype class:

ConcretePrototype prototype = new ConcretePrototype { Name = "Original" };
ConcretePrototype clone = prototype.Clone();
clone.Name = "Cloned";

Console.WriteLine(prototype.Name);
Console.WriteLine(clone.Name);

Output:

Original
Cloned

In this example, a new ConcretePrototype object is created with a name of “Original”, and then a copy of this object is created using the Clone() method and the name is changed to “Cloned”. The original object and the cloned object are then displayed.

The Prototype pattern allows you to create new objects by copying existing objects, which can be faster and more memory-efficient than creating new objects from scratch. It’s especially useful when creating new objects is an expensive or complex operation, such as loading data from a database, generating random values, or performing complex calculations.

It’s worth noting that, while it’s using the MemberwiseClone method to create the new object, this method is providing shallow copy which means that it copies only the references to the objects, it means that if the object has references to other objects, it will create new reference to the same objects. In some cases, you may want to create a deep copy, it’s possible to use serialization or define a custom copy constructor.

Adapter pattern

The Adapter pattern is a structural design pattern that allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class. This pattern can be used to make existing classes work with others without modifying their source code.

Here’s an example of a simple implementation of the Adapter pattern in C#:

public interface ITarget
{
    void Request();
}

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

public class Adapter : Adaptee, ITarget
{
    public void Request()
    {
        SpecificRequest();
    }
}

In this example, we have an interface ITarget that defines a method Request(), and an existing class Adaptee that has a method SpecificRequest(). The Adapter class wraps an instance of the Adaptee class and implements the ITarget interface. The Request() method in the Adapter class calls the SpecificRequest() method of the Adaptee class.

Here’s an example of how to use the Adapter class:

ITarget target = new Adapter();
target.Request();

Output:

Specific Request made

In this example, the target variable is of type ITarget, which is an interface and not the concrete class Adaptee. But the request method is calling the method from Adaptee.

The Adapter pattern allows you to create a wrapper around an existing class, allowing the wrapper to adapt the interface of the existing class to match the interface that is required. This pattern is useful when you need to use an existing class in a new context, and the existing class does not meet the requirements of the new context. It’s a good way to integrate different systems and libraries, or to make them work together in a new way.

It’s worth noting that, Adapter pattern is also known as Wrapper, it’s a classic GoF pattern. It’s important to notice that it doesn’t modify the existing class and also it’s not related to inheritance, it’s related to composition. Also, it’s possible to use this pattern in other ways like adapting interface, adapting class, and adapting object

Bridge pattern

The Bridge pattern is a structural design pattern that separates an object’s interface from its implementation, so you can vary or replace the implementation without changing the client code. This pattern allows you to change the implementation of an object without affecting the client code that uses it.

Here’s an example of a simple implementation of the Bridge pattern in C#:

public interface IBridge
{
    string OperationImp();
}

public class ImplementationA : IBridge
{
    public string OperationImp()
    {
        return "Implementation A";
    }
}

public class ImplementationB : IBridge
{
    public string OperationImp()
    {
        return "Implementation B";
    }
}

public abstract class AbstractBridge
{
    private readonly IBridge _bridge;
    protected AbstractBridge(IBridge bridge)
    {
        _bridge = bridge;
    }

    public virtual string Operation()
    {
        return "Abstract: " + _bridge.OperationImp();
    }
}

public class ConcreteBridge1 : AbstractBridge
{
    public ConcreteBridge1(IBridge bridge) : base(bridge)
    {
    }

    public override string Operation()
    {
        return "Concrete1: " + base.Operation();
    }
}

public class ConcreteBridge2 : AbstractBridge
{
    public ConcreteBridge2(IBridge bridge) : base(bridge)
    {
    }

    public override string Operation()
    {
        return "Concrete2: " + base.Operation();
    }
}

In this example, we have an interface IBridge that defines a method OperationImp(), and two concrete classes ImplementationA and ImplementationB that implement this interface. The AbstractBridge is an abstract class that has a private field of type IBridge and it encapsulate it, this class has an Operation that calls the encapsulated object’s OperationImp method and adds ConcreteBridge1 and ConcreteBridge2 are concrete classes that inherit from AbstractBridge, and they both override the Operation() method to add more text to the output.

Here’s an example of how to use the Bridge pattern:

IBridge implementation = new ImplementationA();
AbstractBridge bridge1 = new ConcreteBridge1(implementation);
Console.WriteLine(bridge1.Operation());

implementation = new ImplementationB();
AbstractBridge bridge2 = new ConcreteBridge2(implementation);
Console.WriteLine(bridge2.Operation());

Output:-

Concrete1: Abstract: Implementation A
Concrete2: Abstract: Implementation B

In this example, the implementation variable is of type IBridge, which is an interface and it can be set to be an instance of either ImplementationA or ImplementationB classes, this way the client code doesn’t need to be aware of the specific implementation. The bridge1 and bridge2 variables are of type AbstractBridge, which is an abstract class, but they are set to be instances of ConcreteBridge1 and ConcreteBridge2 classes respectively. When the Operation() method is called on these instances, it returns a string that includes the text from the AbstractBridge class, the ConcreteBridge1 or ConcreteBridge2 class, and the ImplementationA or ImplementationB class.

The Bridge pattern allows you to separate the interface of an object from its implementation, so you can change the implementation without affecting the client code. This pattern is useful when you want to be able to change the implementation of a class without affecting the client code that uses it. It also allows to extend the implementation and the abstraction separately. It’s a good way to reduce the complexity of your code and make it more maintainable.

Composite pattern

The Composite pattern is a structural design pattern that allows you to build structures of objects with a tree-like shape, where some objects are composite (they contain other objects), and others are leaf objects (they do not contain any other objects). This pattern provides a way to work with individual objects and compositions of objects in a uniform way.

Here’s an example of a simple implementation of the Composite pattern in C#:

public abstract class Component
{
    public abstract void Operation();
}

public class Leaf : Component
{
    public override void Operation()
    {
        Console.WriteLine("Leaf Operation");
    }
}

public class Composite : Component
{
    private List<Component> _children = new List<Component>();

    public override void Operation()
    {
        Console.WriteLine("Composite Operation");

        foreach (var component in _children)
        {
            component.Operation();
        }
    }

    public void Add(Component component)
    {
        _children.Add(component);
    }

    public void Remove(Component component)
    {
        _children.Remove(component);
    }
}

In this example, Component is an abstract class that defines the Operation() method, Leaf

and Composite are concrete classes that implement the Component interface. The Leaf class represents leaf objects and only implements the Operation() method, while the Composite class represents composite objects, it holds a list of child Component objects and implements the Operation() method, it also has Add and Remove methods that allow you to add and remove child components.

Here’s an example of how to use the Composite pattern:

Component leaf1 = new Leaf();
Component leaf2 = new Leaf();

Component composite = new Composite();
composite.Add(leaf1);
composite.Add(leaf2);
composite.Operation();

Output:

Composite Operation
Leaf Operation
Leaf Operation

In this example, two leaf objects are created, and then added to a composite object. When the Operation() method is called on the composite object, it calls the Operation() method on all of its child objects, which in this case are the leaf objects, displaying the message “Leaf Operation” twice.

The Composite pattern provides a way to work with individual objects and compositions of objects in a uniform way. This pattern allows you to create complex structures, such as trees, where each node can be a leaf or a composite of other nodes. This pattern also enables you to treat individual objects and compositions of objects in a uniform way. It’s a good way to represent hierarchical structure of objects and also it’s a good way to build more complex structure out of simple ones.

It’s worth noting that, Composite pattern is closely related with the Iterator pattern, it’s a way to navigate the composite structure and use its elements. Also it’s important to note that this pattern can make your code more complex as it increases the number of objects in your codebase.

Decorator pattern

The Decorator pattern is a structural design pattern that allows you to add new behaviors to existing objects by wrapping them in a decorator object. This pattern provides a flexible way to extend the functionality of an object without modifying its source code.

Here’s an example of a simple implementation of the Decorator pattern in C#:

public interface IComponent
{
    string Operation();
}

public class ConcreteComponent : IComponent
{
    public string Operation()
    {
        return "Concrete Component";
    }
}

public abstract class Decorator : IComponent
{
    private readonly IComponent _component;

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

    public virtual string Operation()
    {
        return _component.Operation();
    }
}

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

    public override string Operation()
    {
        return $"ConcreteDecoratorA({base.Operation()})";
    }
}

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

    public override string Operation()
    {
        return $"ConcreteDecoratorB({base.Operation()})";
    }
}

In this example, IComponent is an interface that defines a single method Operation(). The ConcreteComponent class is a concrete implementation of this interface, it simply returns a string of “Concrete Component” when the Operation() is called. Decorator is an abstract class that also implements the IComponent interface, it holds a private reference to an IComponent object, and it defines the same Operation() method that calls the Operation() method of the encapsulated object. ConcreteDecoratorA and ConcreteDecoratorB are concrete classes that inherit from Decorator, they wrap the IComponent object and add their own functionality to the Operation() method by prefixing the output of the wrapped object with their own name.

Here’s an example of how to use the Decorator pattern:

IComponent component = new ConcreteComponent();
component = new ConcreteDecoratorA(component);
component = new ConcreteDecoratorB(component);
Console.WriteLine(component.Operation());

Output:

ConcreteDecoratorB(ConcreteDecoratorA(Concrete Component))

In this example, a new ConcreteComponent object is created and then it’s wrapped in two ConcreteDecoratorA and ConcreteDecoratorB decorators. When the Operation() method is called on the final decorator, it will execute the Operation() method on the ConcreteDecoratorB first, which will call the Operation() method on the ConcreteDecoratorA before that and finally calling the Operation() method on the ConcreteComponent object, adding its own prefix to the output of each call.

The Decorator pattern allows you to add new behaviors to existing objects without modifying their source code. This pattern provides a flexible way to extend the functionality of an object at runtime, and it also allows you to create a flexible and reusable code by creating decorators that can be combined in different ways to achieve different behaviors. It’s useful when you want to add or change the functionality of an object dynamically and also it’s useful when you want to add functionality to a class hierarchy without affecting the existing code.

It’s worth noting that, It’s important to notice that the decorator pattern can lead to a high number of small classes, and the decorator objects and their relationship can become complex, making it harder to understand and maintain your code. Also, the decorator can have a similar performance impact to inheritance, it could lead to a high number of objects.

Facade pattern

The Facade pattern is a structural design pattern that provides a simplified interface to a complex system of objects, hiding the underlying complexity and dependencies. This pattern allows you to provide a single, unified API for a set of interfaces in a subsystem, making it easier to use and understand.

Here’s an example of a simple implementation of the Facade pattern in C#:

public class SubsystemA
{
    public string OperationA1()
    {
        return "Subsystem A, Method A1\n";
    }

    public string OperationA2()
    {
        return "Subsystem A, Method A2\n";
    }
}

public class SubsystemB
{
    public string OperationB1()
    {
        return "Subsystem B, Method B1\n";
    }

    public string OperationB2()
    {
        return "Subsystem B, Method B2\n";
    }
}

public class Facade
{
    private SubsystemA _subA = new SubsystemA();
    private SubsystemB _subB = new SubsystemB();

    public string Operation1()
    {
        return "Facade Operation 1\n" +
            _subA.OperationA1() +
            _subB.OperationB1();
    }

    public string Operation2()
    {
        return "Facade Operation 2\n" +
            _subA.OperationA2() +
            _subB.OperationB2();
    }
}

In this example, SubsystemA and SubsystemB are two subsystems with their own interface and functionality. Facade is a class that provides a simplified interface to these subsystems, it holds the references to both subsystems, it has Operation1 and Operation2 that use the methods of the subsystems.

Here’s an example of how to use the Facade pattern:

var facade = new Facade();
Console.WriteLine(facade.Operation1());
Console.WriteLine(facade.Operation2());

Output:-

Facade Operation 1
Subsystem A, Method A1
Subsystem B, Method B1

Facade Operation 2
Subsystem A, Method A2
Subsystem B, Method B2

In this example, the Facade object provides a simplified interface to two different subsystems, by using its own methods Operation1() and Operation2(), it hides the underlying complexity of the subsystems, which the client code does not need to be aware of. The client code only needs to know about the Facade object and its methods to use the subsystems, making it easier to use and understand.

The Facade pattern makes a complex system easier to use by providing a unified and simpler interface to it. This pattern is useful when you want to provide a simple, easy-to-understand, and easy-to-use interface to a complex system, which will make your code more maintainable and testable. It’s also useful when you want to create a layer of abstraction between a system and its clients.

It’s worth noting that, facade design pattern is closely related to the proxy design pattern. The main difference is that a proxy controls access to the original object while a facade only simplifies the interface, although both design pattern are providing a simpler interface to complex systems.

Chain of Responsibility pattern

The Chain of Responsibility pattern is a behavioral design pattern that allows you to process a request through a chain of objects, where each object has the opportunity to handle the request or to pass it on to the next object in the chain. This pattern decouples the sender of a request from its receiver, by giving multiple objects an opportunity to handle the request.

Here’s an example of a simple implementation of the Chain of Responsibility pattern in C#:

public abstract class Handler
{
    protected Handler Successor { get; set; }

    public void SetSuccessor(Handler successor)
    {
        Successor = successor;
    }

    public abstract void HandleRequest(int request);
}

public class ConcreteHandlerA : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 0 && request < 10)
        {
            Console.WriteLine("Request " + request + " handled by ConcreteHandlerA");
        }
        else if (Successor != null)
        {
            Successor.HandleRequest(request);
        }
    }
}

public class ConcreteHandlerB : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 10 && request < 20)
        {
            Console.WriteLine("Request " + request + " handled by ConcreteHandlerB");
        }
        else if (Successor != null)
        {
            Successor.HandleRequest(request);
        }
    }
}

In this example, Handler is an abstract class that defines the HandleRequest method, and ConcreteHandlerA and ConcreteHandlerB are concrete classes that inherit from Handler. Each class has a certain range of integers that it can handle, and if the request falls outside of this range, it passes the request to its successor. The Successor property holds the next handler in the chain, which could be another concrete handler or null if there is no more handler to process the request.

Here’s an example of how to use the Chain of Responsibility pattern:

var handlerA = new ConcreteHandlerA();
var handlerB = new ConcreteHandlerB();
handlerA.SetSuccessor(handlerB);

handlerA.HandleRequest(5);
handlerA.HandleRequest(15);

Output:-

Request 5 handled by ConcreteHandlerA
Request 15 handled by ConcreteHandlerB

In this example, two ConcreteHandlerA and ConcreteHandlerB objects are created and chained together, with ConcreteHandlerA as the first handler and ConcreteHandlerB as its successor. When the HandleRequest(5) method is called on the ConcreteHandlerA, it handles the request because the value is within its range, and the output is “Request 5 handled by ConcreteHandlerA”. When the HandleRequest(15) method is called, ConcreteHandlerA does not handle it because it falls outside of its range. So it passes the request on to its successor ConcreteHandlerB which handles it within its range and the output is “Request 15 handled by ConcreteHandlerB”.

The Chain of Responsibility pattern allows you to process a request through a chain of objects, and it’s a good way to create a flexible and reusable code by creating a chain of handlers that can be combined in different ways to achieve different behaviors. It’s useful when you want to process a request through a dynamic set of objects, it also allows to add or remove handlers from the chain at runtime.

It’s worth noting that, the Chain of Responsibility pattern might lead to a longer chain of objects, which could make the program harder to understand and maintain. Also, the pattern can make it harder to figure out which object handles a request. However, if the number of handlers is not too large, the pattern can be very effective in handling requests.

Command pattern

The Command pattern is a behavioral design pattern that allows you to encapsulate a request as an object, separating the command itself from the object that initiates the request. This pattern enables the decoupling of the sender and receiver of a request, making it easier to add new commands and new objects that handle requests, without modifying existing code.

Here’s an example of a simple implementation of the Command pattern in C#:

public interface ICommand
{
    void Execute();
}

public class ConcreteCommandA : ICommand
{
    private Receiver _receiver;
    public ConcreteCommandA(Receiver receiver)
    {
        _receiver = receiver;
    }
    public void Execute()
    {
        _receiver.ActionA();
    }
}

public class ConcreteCommandB : ICommand
{
    private Receiver _receiver;
    public ConcreteCommandB(Receiver receiver)
    {
        _receiver = receiver;
    }
    public void Execute()
    {
        _receiver.ActionB();
    }
}

public class Receiver
{
    public void ActionA()
    {
        Console.WriteLine("Performing action A.");
    }
    public void ActionB()
    {
        Console.WriteLine("Performing action B.");
    }
}

public class Invoker
{
    private ICommand _command;
    public void SetCommand(ICommand command)
    {
        _command = command;
    }
    public void Invoke()
    {
        _command.Execute();
    }
}

In this example, ICommand is an interface that defines a single method Execute(), ConcreteCommandA and ConcreteCommandB are concrete classes that implement the ICommand interface. They both have a reference to Receiver and they’re able to perform some action on the Receiver. Receiver contains the business logic and Invoker holds a reference to ICommand, it’s responsible for executing the command when needed.

Here’s an example of how to use the Command pattern:

var receiver = new Receiver();
ICommand commandA = new ConcreteCommandA(receiver);
ICommand commandB = new ConcreteCommandB(receiver);

var invoker = new Invoker();
invoker.SetCommand(commandA);
invoker.Invoke(); // Output: Performing action A.
invoker.SetCommand(commandB);
invoker.Invoke(); // Output: Performing action B.

In this example, two ConcreteCommandA and ConcreteCommandB objects are created and each one encapsulates a request to perform an action on the Receiver object. The Invoker object holds a reference to an ICommand object and it’s responsible for executing the command when needed.

When the invoker.Invoke() method is called with the commandA, it calls the Execute() method on the ConcreteCommandA object, which then calls the ActionA() method on the Receiver object, which performs the action and prints “Performing action A.”. When the invoker.Invoke() method is called with the commandB, it calls the Execute() method on the ConcreteCommandB object, which then calls the ActionB() method on the Receiver object, which performs the action and prints “Performing action B.”.

The Command pattern allows you to encapsulate a request as an object, decoupling the sender and receiver of the request. It makes it easier to add new commands and new objects that handle requests without modifying existing code. It’s useful when you want to queue or log requests, support undo/redo, or implement deferred execution of a request.

It’s worth noting that, while the command pattern can make it easier to add new commands, it can also make it harder to understand the relationships between the objects, as well as lead to an increase in the number of objects in your program. However, if the number of commands is not too large, this pattern can be a very effective way to handle requests.

Mediator pattern

The Mediator pattern is a behavioral design pattern that allows objects to communicate with each other through a mediator object, rather than communicating directly with each other. This pattern promotes loose coupling by keeping objects from referring to each other explicitly, and it allows objects to be added or removed from the communication without affecting the other objects.

Here’s an example of a simple implementation of the Mediator pattern in C#:

public interface IMediator
{
    void Send(string message, Colleague sender);
}

public abstract class Colleague
{
    protected IMediator _mediator;

    public Colleague(IMediator mediator)
    {
        _mediator = mediator;
    }
}

public class ConcreteColleagueA : Colleague
{
    public ConcreteColleagueA(IMediator mediator) : base(mediator) { }

    public void Send(string message)
    {
        _mediator.Send(message, this);
    }

    public void Notify(string message)
    {
        Console.WriteLine("Colleague A receives the message: " + message);
    }
}

public class ConcreteColleagueB : Colleague
{
    public ConcreteColleagueB(IMediator mediator) : base(mediator) { }

    public void Send(string message)
    {
        _mediator.Send(message, this);
    }

    public void Notify(string message)
    {
        Console.WriteLine("Colleague B receives the message: " + message);
    }
}

public class ConcreteMediator : IMediator
{
    private ConcreteColleagueA _colleagueA;
    private ConcreteColleagueB _colleagueB;

    public ConcreteColleagueA ColleagueA
    {
        set { _colleagueA = value; }
    }

    public ConcreteColleagueB ColleagueB
    {
        set { _colleagueB = value; }
    }

    public void Send(string message, Colleague sender)
    {
        if (sender == _colleagueA)
        {
            _colleagueB.Notify(message);
        }
        else
        {
            _colleagueA.Notify(message);
        }
    }
}

In this example, IMediator is an interface that defines a single method Send(), Colleague is an abstract class that has a reference to the mediator object, ConcreteColleagueA and ConcreteColleagueB are concrete classes that inherits from Colleague. They both have Send() method that use the mediator to communicate with each other. ConcreteMediator is an implementation of the IMediator interface. It holds the references to ConcreteColleagueA and ConcreteColleagueB, and it’s responsible for routing the message from one colleague to another, based on the sender.

Here’s an example of how to use the Mediator pattern:

var mediator = new ConcreteMediator();

var colleagueA = new ConcreteColleagueA(mediator);
var colleagueB = new ConcreteColleagueB(mediator);

mediator.ColleagueA = colleagueA;
mediator.ColleagueB = colleagueB;

colleagueA.Send("Hello from colleague A");
colleagueB.Send("Hello from colleague B");

In this example, two ConcreteColleagueA and ConcreteColleagueB objects are created, and each one has a reference to a ConcreteMediator object. The ConcreteMediator holds references to both ConcreteColleagueA and ConcreteColleagueB objects. When the colleagueA.Send("Hello from colleague A") is called, it uses the mediator to send the message to colleagueB, ConcreteMediator receives the message and routes it to the correct recipient which is ColleagueB and it Notifies Colleague B with the message received. Similarly, when colleagueB.Send("Hello from colleague B") is called, it sends the message to ColleagueA and ColleagueA gets notified with the message received.

The Mediator pattern promotes loose coupling by keeping objects from referring to each other explicitly, it allows objects to be added or removed from the communication without affecting the other objects. It’s useful when you have a complex system of objects that communicate with each other in many ways, it can help you to make the system more flexible and maintainable.

Observer pattern

The Observer pattern is a behavioral design pattern that allows objects (observers) to be notified of changes to the state of another object (subject), without the subject and observer being tightly coupled. This pattern promotes loose coupling by keeping the subject and observer from referring to each other explicitly.

Here’s an example of a simple implementation of the Observer pattern in C#:

public interface IObserver
{
    void Update(ISubject subject);
}

public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

public class ConcreteSubject : ISubject
{
    private List<IObserver> _observers = new List<IObserver>();
    private string _state;

    public string State
    {
        get { return _state; }
        set
        {
            _state = value;
            Notify();
        }
    }

    public void Attach(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in _observers)
        {
            observer.Update(this);
        }
    }
}

public class ConcreteObserver : IObserver
{
    public void Update(ISubject subject)
    {
        if (subject is ConcreteSubject concreteSubject)
        {
            Console.WriteLine("State of the subject has changed to " + concreteSubject.State);
        }
    }
}

In this example, IObserver is an interface that defines a single method Update(), ISubject is an interface that defines methods for attaching and detaching observers, as well as a method for notifying the observers of a change in the state of the subject. The ConcreteSubject and ConcreteObserver classes implement the ISubject and IObserver interfaces, respectively.

Here’s an example of how to use the Observer pattern:

var subject = new ConcreteSubject();

var observer1 = new ConcreteObserver();
var observer2 = new ConcreteObserver();

subject.Attach(observer1);
subject.Attach(observer2);

subject.State = "State 1";
subject.State = "State 2";

In this example, ConcreteSubject object is created and two ConcreteObserver objects are created and registered as observers of the subject. When the subject’s state is changed by calling subject.State = "State 1" or subject.State = "State 2", the Notify() method is called, which causes the registered observers to be notified of the change via the Update() method, observer will print the new state of the subject “State of the subject has changed to State 1” or “State of the subject has changed to State 2”

The Observer pattern allows you to create a system where objects can be notified of changes to the state of other objects without being tightly coupled, making it easy to add or remove observer

State pattern

The State pattern is a behavioral design pattern that allows an object to change its behavior depending on its internal state. The pattern allows the object to transition between different states and to execute different actions based on the current state. This pattern promotes loose coupling by keeping the state-specific behavior separate from the object that uses that behavior.

Here’s an example of a simple implementation of the State pattern in C#:

public interface IState
{
    void Handle();
}

public class ConcreteStateA : IState
{
    public void Handle()
    {
        Console.WriteLine("Handling in ConcreteStateA.");
    }
}

public class ConcreteStateB : IState
{
    public void Handle()
    {
        Console.WriteLine("Handling in ConcreteStateB.");
    }
}

public class Context
{
    private IState _state;

    public Context(IState state)
    {
        _state = state;
    }

    public void Request()
    {
        _state.Handle();
    }

    public IState State
    {
        set { _state = value; }
    }
}

In this example, IState is an interface that defines a single method Handle(), ConcreteStateA and ConcreteStateB are concrete classes that implement the IState interface and define the state-specific behavior. Context is an object that holds the current state, and it’s responsible for delegating the request to the current state.

Here’s an example of how to use the State pattern:

var context = new Context(new ConcreteStateA());
context.Request(); // Output: Handling in ConcreteStateA.
context.State = new ConcreteStateB();
context.Request(); // Output: Handling in ConcreteStateB.

In this example, a Context object is created with an initial state of ConcreteStateA. When the Request() method is called, it delegates the request to the current state, ConcreteStateA, which handles the request and prints “Handling in ConcreteStateA.”. Then, the state is changed to ConcreteStateB by setting the State property on the context object, and the Request() method is called again, which causes the request to be handled by ConcreteStateB and prints “Handling in ConcreteStateB.”