Design Patterns en C#

Patterns creationnels

Singleton

public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();
    public static Singleton Instance { get { return instance; } }

    // Private constructor to prevent instantiation outside the class
    private Singleton() {}
}

Utilisé lorsqu'une seule instance d'une classe est nécessaire.

Factory Method

public abstract class Creator
{
    public abstract Product FactoryMethod();

    public void AnOperation()
    {
        Product product = FactoryMethod();
        // Use the product
    }
}

public class ConcreteCreator : Creator
{
    public override Product FactoryMethod()
    {
        return new ConcreteProduct();
    }
}

Utilisé pour créer des objets sans spécifier la classe exacte à utiliser.

Patterns structurels

Adapter

public interface Target
{
    void Request();
}

public class Adaptee
{
    public void SpecificRequest()
    {
        // Do something
    }
}

public class Adapter : Target
{
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee)
    {
        this.adaptee = adaptee;
    }

    public override void Request()
    {
        adaptee.SpecificRequest();
    }
}

Utilisé pour rendre une interface incompatibles compatible.

Decorator

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

public class ConcreteComponent : Component
{
    public override void Operation()
    {
        // Do something
    }
}

public abstract class Decorator : Component
{
    protected Component component;

    public Decorator(Component component)
    {
        this.component = component;
    }

    public override void Operation()
    {
        component.Operation();
    }
}

Utilisé pour ajouter des responsabilités dynamiquement à un objet.

Patterns comportementaux

Observer

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

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

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

    public void Attach(Observer observer)
    {
        observers.Add(observer);
    }

    public void Detach(Observer observer)
    {
        observers.Remove(observer);
    }

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

Utilisé pour créer une dépendance unidirectionnelle entre objets source et objets observateurs.

Strategy

public interface IStrategy
{
    void Execute();
}

public class ConcreteStrategyA : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("Executing strategy A");
    }
}

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

Utilisé pour définir une famille d'algorithms, encapsuler chacun d'eux et rendre les algorithmes interchangeables.