Patrones de diseño en C# con ejemplos de código

Patrones de diseño en C#: guía completa con ejemplos

Los patrones de diseño (Design Patterns) son soluciones probadas para problemas típicos que surgen durante el desarrollo de software. En el ecosistema .NET y C#, el conocimiento de los patrones es especialmente importante, ya que muchos de ellos están integrados directamente en la plataforma (por ejemplo, IDisposable para el patrón Dispose). En este artículo, analizaremos los tres grupos principales de patrones según la clasificación GoF (Gang of Four) con ejemplos prácticos en C#.

Patrones creacionales (Creational Patterns)

Los patrones creacionales se encargan de la creación de objetos, haciendo que el sistema sea independiente de la forma en que se crean, componen y representan.

Singleton (Singleton)

Garantiza que una clase tenga solo una instancia y proporciona un punto de acceso global a ella. En C#, se usa a menudo para trabajar con loggers, caché o configuración.

public sealed class Logger{    private static readonly Lazy<Logger> _instance =         new Lazy<Logger>(() => new Logger());

    public static Logger Instance => _instance.Value;

    private Logger() { }

    public void Log(string message)    {        Console.WriteLine($"[{DateTime.Now}] {message}");    }}

// UsoLogger.Instance.Log("Aplicación iniciada");

Factory Method (Método de fábrica)

Define una interfaz para crear un objeto, pero permite que las subclases alteren el tipo de objeto creado. Es ideal para lógica que debe ser extensible.

public interface ITransport{    void Deliver();}

public class Truck : ITransport{    public void Deliver() => Console.WriteLine("Entrega por carretera");}

public class Ship : ITransport{    public void Deliver() => Console.WriteLine("Entrega por mar");}

public abstract class Logistics{    public abstract ITransport CreateTransport();

    public void PlanDelivery()    {        var transport = CreateTransport();        transport.Deliver();    }}

public class RoadLogistics : Logistics{    public override ITransport CreateTransport() => new Truck();}

public class SeaLogistics : Logistics{    public override ITransport CreateTransport() => new Ship();}

// UsoLogistics logistics = new RoadLogistics();logistics.PlanDelivery(); // Entrega por carretera

Patrones estructurales (Structural Patterns)

Los patrones estructurales definen formas de construir clases y objetos para formar estructuras más grandes.

Adapter (Adaptador)

Convierte la interfaz de una clase en otra interfaz esperada por el cliente. Se usa a menudo para la integración con bibliotecas de terceros o código heredado.

// Interfaz objetivo (ITarget)public interface IXmlParser{    string ParseToXml(string data);}

// Clase adaptable (Adaptee)public class JsonParser{    public string ParseToJson(string data)     {        return $"{{\\"data\\": \\"{data}\\"}}";    }}

// Adaptadorpublic class JsonToXmlAdapter : IXmlParser{    private readonly JsonParser _jsonParser;

    public JsonToXmlAdapter(JsonParser jsonParser)    {        _jsonParser = jsonParser;    }

    public string ParseToXml(string data)    {        var json = _jsonParser.ParseToJson(data);        // Conversión muy simple de JSON a XML        return $"<data>{data}</data>";    }}

// Usovar adapter = new JsonToXmlAdapter(new JsonParser());string xml = adapter.ParseToXml("Hello");Console.WriteLine(xml); // <data>Hello</data>

Decorator (Decorador)

Añade dinámicamente nuevas responsabilidades a un objeto. En C#, este patrón se implementa a menudo mediante herencia o composición.

public interface INotifier{    void Send(string message);}

public class E