C# Design Patterns

C# is a versatile and feature-rich programming language, widely used for building a wide range of applications. However, as projects grow in complexity, maintaining code structure and scalability becomes crucial. This is where design patterns come into play, offering time-tested and proven approaches to organizing code, enhancing reusability, and promoting maintainability.

Design patterns are reusable solutions to common software design problems. They help developers create flexible, maintainable, and scalable code. In C#, developers can implement various design patterns to improve the structure and architecture of the applications.

C# Design Patterns

Let's go over some common design patterns and their implementations in C#:

1. Singleton Pattern

The singleton pattern ensures that a class has only one instance and provides a global point of access to that instance.

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

    private Singleton() { }

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

2. Factory Pattern

The Factory pattern creates objects without specifying the exact class of the object that will be created. It provides an interface for creating objects and allows the subclasses to alter the type of objects that will be created.

public interface IProduct
{
    void Display();
}

public class ConcreteProductA : IProduct
{
    public void Display() => Console.WriteLine("Product A");
}

public class ConcreteProductB : IProduct
{
    public void Display() => Console.WriteLine("Product B");
}

public class ProductFactory
{
    public IProduct CreateProduct(string type)
    {
        switch (type)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new ArgumentException("Invalid product type");
        }
    }
}

3. Observer Pattern

The Observer pattern allows an object (subject) to notify its dependent objects (observers) about any state changes.

public interface IObserver
{
    void Update(string message);
}

public class ConcreteObserver : IObserver
{
    public void Update(string message)
    {
        Console.WriteLine("Received message: " + message);
    }
}

public class Subject
{
    private List<IObserver> observers = new List<IObserver>();

    public void AddObserver(IObserver observer)
    {
        observers.Add(observer);
    }

    public void RemoveObserver(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void NotifyObservers(string message)
    {
        foreach (var observer in observers)
        {
            observer.Update(message);
        }
    }
}

4. Strategy Pattern

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows the client to choose the algorithm to be used at runtime.

public interface IStrategy
{
    void Execute();
}

public class ConcreteStrategyA : IStrategy
{
    public void Execute() => Console.WriteLine("Strategy A");
}

public class ConcreteStrategyB : IStrategy
{
    public void Execute() => Console.WriteLine("Strategy B");
}

public class Context
{
    private IStrategy strategy;

    public Context(IStrategy strategy)
    {
        this.strategy = strategy;
    }

    public void SetStrategy(IStrategy strategy)
    {
        this.strategy = strategy;
    }

    public void ExecuteStrategy()
    {
        strategy.Execute();
    }
}

Conclusion

The use of design patterns in C# can be a game-changer for developers seeking to elevate their codebase's quality, maintainability, and extensibility. By adopting these tried and tested solutions, developers can streamline their development process and create more scalable and flexible applications. Design patterns provide a structured approach to solving recurring problems, enabling teams to collaborate effectively and share a common language for discussing solutions. However, it's crucial to exercise caution and avoid overusing patterns, as applying them indiscriminately can lead to unnecessary complexity and reduced code readability. Striking the right balance and understanding the context in which each pattern fits best will ensure that these patterns enhance, rather than hinder, the overall development experience.