close

Articles Home » Programming Languages » C# » C# Design Patterns and Best Practices

C# Design Patterns and Best Practices

Design patterns are tried and tested solutions to common software design problems. They can help improve the structure, efficiency, and maintainability of your code. In this article, we will explore a variety of design patterns and best practices in C# programming. By the end of this guide, you will have a deeper understanding of how to make your C# code more robust and scalable.

1. Creational Patterns

Creational design patterns deal with object creation mechanisms. They provide more control and flexibility over object instantiation.

1.1. Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance. It is useful when you need to enforce that only one object of a particular class should exist.

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazyInstance = new Lazy<Singleton>(() => new Singleton());
    public static Singleton Instance => lazyInstance.Value;

    private Singleton() { }
}Code language: C# (cs)

1.2. Factory Method Pattern

The Factory Method pattern allows creating objects without specifying their concrete types. Instead, a factory method creates objects based on a parameter or a configuration value.

public interface IProduct { }
public class ConcreteProductA : IProduct { }
public class ConcreteProductB : IProduct { }

public static class ProductFactory
{
    public static IProduct CreateProduct(string productType)
    {
        switch (productType)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new ArgumentException("Invalid product type", nameof(productType));
        }
    }
}Code language: C# (cs)

2. Structural Patterns

Structural patterns define relationships between classes or objects, simplifying their interactions and promoting code reusability.

2.1. Adapter Pattern

The Adapter pattern allows classes with incompatible interfaces to work together by wrapping an existing class with a new interface.

public interface ITarget
{
    string GetRequest();
}

public class Adaptee
{
    public string GetSpecificRequest()
    {
        return "Specific request";
    }
}

public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;

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

    public string GetRequest()
    {
        return _adaptee.GetSpecificRequest();
    }
}Code language: C# (cs)

2.2. Decorator Pattern

The Decorator pattern allows adding new functionality to an existing object without altering its structure. It involves a set of decorator classes that mirror the type of the objects they extend.

public interface IComponent
{
    string Operation();
}

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

public abstract class Decorator : IComponent
{
    protected 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()})";
    }
}Code language: C# (cs)

3. Behavioral Patterns

Behavioral patterns define the communication between objects and how they interact with each other.

3.1. Observer Pattern

The Observer pattern allows an object, called the subject, to notify other objects, called observers, about changes in its state. The observer pattern promotes a decoupling between the subject and its observers, which can simplify the code and improve maintainability.

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

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

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

    public string State
    {
        get => _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(State);
        }
    }
}

public class ConcreteObserver : IObserver
{
    public void Update(string message)
    {
        Console.WriteLine($"Received update: {message}");
    }
}Code language: C# (cs)

3.2. Strategy Pattern

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

public interface IStrategy
{
    int Execute(int a, int b);
}

public class ConcreteStrategyAdd : IStrategy
{
    public int Execute(int a, int b)
    {
        return a + b;
    }
}

public class ConcreteStrategyMultiply : IStrategy
{
    public int Execute(int a, int b)
    {
        return a * b;
    }
}

public class Context
{
    private IStrategy _strategy;

    public Context(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public void SetStrategy(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public int ExecuteStrategy(int a, int b)
    {
        return _strategy.Execute(a, b);
    }
}Code language: C# (cs)

4. Best Practices

4.1. SOLID Principles

SOLID is an acronym that represents a set of five design principles for writing maintainable and scalable software. They are:

  • Single Responsibility Principle (SRP): A class should have only one reason to change.
  • Open/Closed Principle (OCP): Software entities should be open for extension but closed for modification.
  • Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types.
  • Interface Segregation Principle (ISP): Many client-specific interfaces are better than one general-purpose interface.
  • Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules; both should depend on abstractions.

4.2. Code Reusability and Composition

Compose your application by reusing existing code and combining smaller, independent components. This practice encourages modularity, making your code easier to understand, maintain, and extend.

4.3. Dependency Injection

Dependency Injection (DI) is a technique for achieving Inversion of Control (IoC) between classes and their dependencies. It promotes loose coupling and improves testability. In C#, you can use DI frameworks like Autofac, Unity, or the built-in Microsoft.Extensions.DependencyInjection.

Example Exercise: Implementing a File Conversion System Using C# Design Patterns

In this example exercise, we will implement a file conversion system using various C# design patterns and best practices. Our system will be able to convert between different file formats, such as TXT, JSON, and XML. We will utilize the Factory Method, Strategy, and Singleton patterns in our implementation.

1. Define the File Conversion Interface

Create a common interface that all file converters will implement.

public interface IFileConverter
{
    string Convert(string input);
}Code language: C# (cs)

2. Implement Concrete File Converters

Create concrete file converter classes for TXT, JSON, and XML formats.

// Converter for TXT to JSON format
public class TxtToJsonConverter : IFileConverter
{
    public string Convert(string input)
    {
        // Implementation for converting TXT to JSON
    }
}

// Converter for TXT to XML format
public class TxtToXmlConverter : IFileConverter
{
    public string Convert(string input)
    {
        // Implementation for converting TXT to XML
    }
}

// Converter for JSON to XML format
public class JsonToXmlConverter : IFileConverter
{
    public string Convert(string input)
    {
        // Implementation for converting JSON to XML
    }
}Code language: C# (cs)

3. Implement File Converter Factory (Factory Method Pattern)

Create a factory class that will instantiate the appropriate file converter based on the input and output formats.

public static class FileConverterFactory
{
    public static IFileConverter CreateConverter(string inputFormat, string outputFormat)
    {
        if (inputFormat == "TXT" && outputFormat == "JSON")
            return new TxtToJsonConverter();
        else if (inputFormat == "TXT" && outputFormat == "XML")
            return new TxtToXmlConverter();
        else if (inputFormat == "JSON" && outputFormat == "XML")
            return new JsonToXmlConverter();
        else
            throw new ArgumentException("Invalid input-output format combination");
    }
}Code language: C# (cs)

4. Implement the File Conversion Context (Strategy Pattern)

Create a context class that will use the selected file converter to perform the file conversion.

public class FileConversionContext
{
    private IFileConverter _fileConverter;

    public void SetConverter(IFileConverter fileConverter)
    {
        _fileConverter = fileConverter;
    }

    public string Convert(string input)
    {
        if (_fileConverter == null)
            throw new InvalidOperationException("File converter is not set");

        return _fileConverter.Convert(input);
    }
}Code language: C# (cs)

5. Implement the File Conversion Manager (Singleton Pattern)

Create a file conversion manager class that will manage the file conversion operations. This class will be a singleton to ensure that only one instance exists.

public sealed class FileConversionManager
{
    private static readonly Lazy<FileConversionManager> lazyInstance = new Lazy<FileConversionManager>(() => new FileConversionManager());
    public static FileConversionManager Instance => lazyInstance.Value;

    private readonly FileConversionContext _fileConversionContext = new FileConversionContext();

    private FileConversionManager() { }

    public string Convert(string input, string inputFormat, string outputFormat)
    {
        var converter = FileConverterFactory.CreateConverter(inputFormat, outputFormat);
        _fileConversionContext.SetConverter(converter);
        return _fileConversionContext.Convert(input);
    }
}Code language: C# (cs)

6. Use the File Conversion Manager

Utilize the FileConversionManager to perform file conversions.

class Program
{
    static void Main(string[] args)
    {
        string inputText = "Example input data";
        string inputFormat = "TXT";
        string outputFormat = "JSON";

        try
        {
            string convertedData = FileConversionManager.Instance.Convert(inputText, inputFormat, outputFormat);
            Console.WriteLine($"Converted data: {convertedData}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error occurred: {ex.Message}");
        }
    }
}Code language: C# (cs)

In this example exercise, we have demonstrated the implementation of a file conversion system using various C# design patterns and best practices, such as the Factory Method, Strategy, and Singleton patterns. The FileConversionManager, FileConversionContext, and FileConverterFactory classes work together to perform file conversions between different formats, such as TXT, JSON, and XML. This approach allows for easy extensibility, as adding support for new formats would only require the creation of new converter classes and updating the factory method accordingly.

Related posts: