Understanding Design Patterns in .NET Core: A Comprehensive Guide

Design patterns are essential tools in a developer’s toolkit, providing reusable solutions to common problems encountered during software development. In .NET Core, leveraging these patterns can lead to more robust, maintainable, and scalable applications. This blog will delve into some of the most significant design patterns, offering insights into their implementation and benefits in a .NET Core environment.

1. Introduction to Design Patterns

Design patterns are proven solutions to recurring design problems. They represent best practices refined over time by experienced developers. Patterns fall into three main categories:

• Creational Patterns: Deal with object creation mechanisms.
• Structural Patterns: Concerned with object composition and relationships.
• Behavioral Patterns: Address communication between objects.

Understanding and applying these patterns in .NET Core can significantly enhance your application’s design and performance.

2. Creational Patterns

Singleton Pattern

The Singleton pattern ensures a class has only one instance and provides a global point of access to it. This pattern is particularly useful for logging, configuration settings, and database connections.

Implementation in .NET Core:

public 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;
            }
        }
    }
}

In a .NET Core application, you can register the Singleton service in the Startup.cs file:

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<Singleton>();
}

Factory Pattern

The Factory pattern provides an interface for creating objects but allows subclasses to alter the type of objects that will be created. This pattern is beneficial when the exact type of the object needs to be determined at runtime.

Implementation in .NET Core:

public interface IProduct
{
    void DoWork();
}

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

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

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

3. Structural Patterns

Adapter Pattern

The Adapter pattern allows incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces by wrapping an existing class with a new interface.

Implementation in .NET Core:

public interface ITarget
{
    void Request();
}

public class Adaptee
{
    public void SpecificRequest() => Console.WriteLine("Specific request");
}

public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;

    public Adapter(Adaptee adaptee)
    {
        _adaptee = adaptee;
    }

    public void Request() => _adaptee.SpecificRequest();
}

Decorator Pattern

The Decorator pattern allows behavior to be added to individual objects, dynamically, without affecting the behavior of other objects from the same class. This pattern is useful for adhering to the Single Responsibility Principle.

Implementation in .NET Core:

public interface IComponent
{
    string Operation();
}

public class ConcreteComponent : IComponent
{
    public string Operation() => "ConcreteComponent";
}

public class Decorator : IComponent
{
    private readonly IComponent _component;

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

    public virtual string Operation() => _component.Operation();
}

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

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

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

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

4. Behavioral Patterns

Observer Pattern

The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. This pattern is perfect for implementing distributed event handling systems.

Implementation in .NET Core:

public interface IObserver
{
    void Update();
}

public class ConcreteObserver : IObserver
{
    public void Update() => Console.WriteLine("Observer has been updated");
}

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

    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();
        }
    }
}

Command Pattern

The Command pattern turns a request into a stand-alone object that contains all information about the request. This is particularly useful for implementing undo functionality.

Implementation in .NET Core:

public interface ICommand
{
    void Execute();
}

public class Receiver
{
    public void Action() => Console.WriteLine("Receiver Action");
}

public class ConcreteCommand : ICommand
{
    private readonly Receiver _receiver;

    public ConcreteCommand(Receiver receiver)
    {
        _receiver = receiver;
    }

    public void Execute() => _receiver.Action();
}

public class Invoker
{
    private ICommand _command;

    public void SetCommand(ICommand command) => _command = command;
    public void ExecuteCommand() => _command.Execute();
}

5. Conclusion

Understanding and implementing design patterns in .NET Core can greatly enhance the quality and maintainability of your applications. Creational patterns like Singleton and Factory manage object creation efficiently. Structural patterns like Adapter and Decorator improve the composition of classes and objects. Behavioral patterns like Observer and Command facilitate communication and responsibility distribution among objects.

By incorporating these patterns, you not only solve common design problems but also make your code more understandable and adaptable to future changes. Start applying these patterns in your .NET Core projects and experience the benefits of a well-structured codebase.