Patrones de diseño en C# con ejemplos: de la A a la Z

Patrones de diseño en C# con ejemplos: de la A a la Z

Los patrones de diseño (design patterns) son soluciones probadas para problemas típicos que surgen durante el desarrollo de software. No son código listo para usar, sino plantillas que se pueden adaptar a una situación específica. Para un desarrollador de C#, conocer los patrones no es solo un plus en el currículum, sino una necesidad para crear una arquitectura flexible, mantenible y escalable.

En este artículo, analizaremos los tres grupos principales de patrones según la clasificación GoF (Gang of Four): creacionales, estructurales y de comportamiento. Cada patrón se examinará con un ejemplo práctico en C# (.NET).

Patrones creacionales (Creational Patterns)

Estos patrones gestionan el proceso de creación de objetos, haciendo que el sistema sea independiente de la forma en que se crean. Veamos los dos más populares.

Singleton (Singleton)

Garantiza que una clase tenga solo una instancia y proporciona un punto de acceso global a ella. En C#, para un trabajo seguro en entornos multiproceso, se utiliza Lazy<T>.

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");

Método de fábrica (Factory Method)

Define una interfaz para crear un objeto, pero permite que las subclases alteren el tipo de objeto creado. Es ideal para situaciones en las que el tipo de objeto no se conoce de antemano.

public interface ITransport{    void Deliver();}

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

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

// UsoLogistics logistics = new RoadLogistics();logistics.PlanDelivery(); // Salida: Entrega por tierra

Patrones estructurales (Structural Patterns)

Definen formas de construir relaciones entre objetos, proporcionando flexibilidad y eficiencia en la arquitectura.

Adaptador (Adapter)

Permite que objetos con interfaces incompatibles trabajen juntos. Se usa a menudo al integrar código antiguo o bibliotecas de terceros.

// Interfaz objetivo, esperada por el clientepublic interface IModernPrinter{    void Print(string text);}

// Clase antigua con interfaz incompatiblepublic class OldPrinter{    public void PrintOldStyle(string message)    {        Console.WriteLine($"Impresora antigua: {message}");    }}

// Adaptadorpublic class PrinterAdapter : IModernPrinter{    private readonly OldPrinter _oldPrinter;

    public PrinterAdapter(OldPrinter oldPrinter)    {        _oldPrinter = oldPrinter;    }

    public void Print(string text)    {        _oldPrinter.PrintOldStyle(text);    }}

// UsoIModernPrinter printer = new PrinterAdapter(new OldPrinter());printer.Print("¡Hola, mundo!"); // Salida: Impresora antigua: ¡Hola, mundo!

Decorador (Decorator)

Añade dinámicamente nuevas responsabilidades a un objeto sin modificar su código. Es una alternativa flexible a la herencia.

public interface ICoffee{    double GetCost();    string GetDescription();}

public class SimpleCoffee : ICoffee{