Patrones de Diseño en C#: Guía con Ejemplos y Mejores Prácticas

En el desarrollo de software los patrones de diseño son como las herramientas maestras que moldean y optimizan nuestro código. Si alguna vez te has preguntado cómo crear aplicaciones más eficientes, escalables y fáciles de mantener, ¡estás a punto de descubrirlo!

En esta guía, exploraremos cómo los patrones de diseño pueden convertirse en tus aliados más potentes en el desarrollo de aplicaciones. Desde la definición de qué son los patrones de diseño y cómo utilizarlos, hasta ejemplos prácticos en C# que ilustran su uso en situaciones del mundo real.

Imagina tener en tus manos un conjunto de recetas probadas que te guían en la construcción de soluciones efectivas a problemas comunes en el desarrollo de software.

Los patrones de diseño ofrecen precisamente eso. Son soluciones reutilizables para desafíos que los programadores enfrentan a menudo en su día a día.

Además, los patrones de diseño no solo mejoran la eficiencia del código, sino que también facilitan la colaboración en equipos de desarrollo y reducen los errores.

En esta entrada veremos con ejemplos los tres tipos fundamentales de patrones de diseño: creacionales, estructurales y de comportamiento.

Cada clasificación de los patrones de diseño se centra en diferentes aspectos del diseño y ofrece soluciones específicas para problemas del mundo real.

Los patrones de diseño creacionales se centran en la forma en que los objetos se crean y cómo se instancian. Ejemplos de patrones creacionales incluyen Singleton, Factory Method y Abstract Factory. Estos patrones son especialmente útiles para controlar la creación de objetos de manera eficiente y garantizar que solo haya una instancia de cierta clase.

Los patrones estructurales se refieren a la composición y estructura de las clases y objetos. Ejemplos de patrones estructurales son Adapter, Decorator y Composite. Estos patrones permiten combinar objetos de diferentes formas para lograr funcionalidades más complejas.

Los patrones de comportamiento se centran en la interacción entre objetos y el flujo de ejecución. Patrones como Observer, Strategy y Command permiten definir cómo los objetos interactúan entre sí y cómo se gestionan las solicitudes y acciones.

Los patrones de diseño creacionales son como los arquitectos de la creación de objetos.

Estos patrones se centran en cómo instanciar objetos de manera efectiva y cómo garantizar que se inicialicen correctamente en diferentes contextos. En otras palabras, son los encargados de establecer los cimientos de la construcción de objetos.

El patrón Singleton se encarga de garantizar que una clase tenga una sola instancia y proporciona un punto de acceso global a esa instancia.

Son útiles cuando solo necesitas una instancia de una clase para controlar recursos compartidos, como una conexión a una base de datos. Este patrón garantiza que solo haya una instancia y que esta se reutilice en todo el sistema.

Pero, veamos un ejemplo de código en C# para entenderlo mejor:

using System;

public class Singleton
{
    private static Singleton instance;

    // Constructor privado para evitar la creación de instancias desde fuera de la clase.
    private Singleton() { }

    // Método estático que devuelve la única instancia de la clase.
    public static Singleton GetInstance()
    {
        // Si la instancia aún no ha sido creada, la creamos.
        if (instance == null)
        {
            instance = new Singleton();
        }

        return instance;
    }

    public void MetodoEjemplo()
    {
        Console.WriteLine("¡Método de ejemplo del Singleton!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Acceso al Singleton
        Singleton instancia1 = Singleton.GetInstance();
        Singleton instancia2 = Singleton.GetInstance();

        // Ambas instancias serán la misma
        Console.WriteLine(Object.ReferenceEquals(instancia1, instancia2)); // Salida: True

        // Ejemplo de uso del Singleton
        instancia1.MetodoEjemplo();
    }
}

El código anterior define una clase Singleton con un método GetInstance() que devuelve la única instancia de la clase. El constructor de la clase es privado, lo que significa que no se puede crear una instancia de la clase desde fuera de ella.

La variable instance almacena la única instancia de la clase y se inicializa la primera vez que se llama a GetInstance(). Todas las siguientes llamadas a GetInstance() siempre van a devolver la misma instancia creada previamente.

El ejemplo en el método Main muestra cómo utilizar el Singleton. Ambas instancias creadas son iguales, lo que demuestra que solo existe una instancia de la clase Singleton.

El patrón Factory Method permite la creación de objetos sin especificar la clase exacta que se instanciará. En lugar de crear objetos directamente con el constructor, utilizamos un método de fábrica que devuelve instancias de diferentes subclases según la situación.

Esto es especialmente útil cuando deseas abstraer la lógica de creación y delegarla a subclases específicas.

A continuación muestro el ejemplo en C# de cómo definir un patrón de diseño Factory y de cómo utilizarlo:

using System;

// Interfaz para los productos que pueden ser creados por la fábrica.
public interface IProduct
{
    void Operacion();
}

// Implementación concreta de un producto.
public class ConcreteProductA : IProduct
{
    public void Operacion()
    {
        Console.WriteLine("Operación realizada por el Producto A");
    }
}

// Implementación concreta de otro producto.
public class ConcreteProductB : IProduct
{
    public void Operacion()
    {
        Console.WriteLine("Operación realizada por el Producto B");
    }
}

// Interfaz para la fábrica que crea productos.
public interface IFactory
{
    IProduct FabricarProducto();
}

// Implementación concreta de una fábrica que crea un tipo específico de producto.
public class ConcreteFactoryA : IFactory
{
    public IProduct FabricarProducto()
    {
        return new ConcreteProductA();
    }
}

// Implementación concreta de otra fábrica que crea otro tipo de producto.
public class ConcreteFactoryB : IFactory
{
    public IProduct FabricarProducto()
    {
        return new ConcreteProductB();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Creamos una fábrica de tipo A
        IFactory fabricaA = new ConcreteFactoryA();

        // Uso la fábrica para crear un producto de tipo A
        IProduct productoA = fabricaA.FabricarProducto();
        productoA.Operacion();

        // Creamos una fábrica de tipo B
        IFactory fabricaB = new ConcreteFactoryB();

        // Uso la fábrica para crear un producto de tipo B
        IProduct productoB = fabricaB.FabricarProducto();
        productoB.Operacion();
    }
}

En este ejemplo, el patrón Factory Method se utiliza para crear diferentes tipos de productos a través de una interfaz común llamada IProduct. Las clases ConcreteProductA y ConcreteProductB son implementaciones concretas de productos que implementan esta interfaz.

Luego, las clases ConcreteFactoryA y ConcreteFactoryB son fábricas concretas que implementan la interfaz IFactory. Cada fábrica se encarga de crear un tipo específico de producto.

En el método Main, creamos instancias de las fábricas y utilizamos estas fábricas para crear productos.

Esto permite que el código cliente pueda crear productos sin necesidad de conocer los detalles de su implementación, siguiendo así el principio de abstracción del patrón Factory Method.

El patrón de diseño Abstract Factory se enfoca en la creación de familias de objetos relacionados.

Proporciona una interfaz para crear distintos tipos de objetos, pero delega la responsabilidad de qué clases concretas se deben instanciar a las subclases.

Esto es especialmente útil cuando necesitas crear múltiples objetos interrelacionados, como diferentes componentes de una interfaz de usuario.

using System;

// Interfaz para productos de tipo A
public interface IProductA
{
    void MetodoA();
}

// Interfaz para productos de tipo B
public interface IProductB
{
    void MetodoB();
}

// Interfaz para la fábrica abstracta que crea productos de tipo A y B
public interface IAbstractFactory
{
    IProductA CrearProductoA();
    IProductB CrearProductoB();
}

// Implementación concreta de un producto de tipo A
public class ConcreteProductA1 : IProductA
{
    public void MetodoA()
    {
        Console.WriteLine("Método A de Producto A1");
    }
}

// Implementación concreta de otro producto de tipo A
public class ConcreteProductA2 : IProductA
{
    public void MetodoA()
    {
        Console.WriteLine("Método A de Producto A2");
    }
}

// Implementación concreta de un producto de tipo B
public class ConcreteProductB1 : IProductB
{
    public void MetodoB()
    {
        Console.WriteLine("Método B de Producto B1");
    }
}

// Implementación concreta de otro producto de tipo B
public class ConcreteProductB2 : IProductB
{
    public void MetodoB()
    {
        Console.WriteLine("Método B de Producto B2");
    }
}

// Implementación concreta de una fábrica abstracta que crea productos de tipo A y B
public class ConcreteFactory1 : IAbstractFactory
{
    public IProductA CrearProductoA()
    {
        return new ConcreteProductA1();
    }

    public IProductB CrearProductoB()
    {
        return new ConcreteProductB1();
    }
}

// Otra implementación concreta de una fábrica abstracta que crea productos de tipo A y B
public class ConcreteFactory2 : IAbstractFactory
{
    public IProductA CrearProductoA()
    {
        return new ConcreteProductA2();
    }

    public IProductB CrearProductoB()
    {
        return new ConcreteProductB2();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Creamos una fábrica de productos tipo 1
        IAbstractFactory fabrica1 = new ConcreteFactory1();

        // Uso la fábrica para crear productos de tipo A y B
        IProductA productoA1 = fabrica1.CrearProductoA();
        IProductB productoB1 = fabrica1.CrearProductoB();

        // Uso los productos
        productoA1.MetodoA(); 
        productoB1.MetodoB(); 

        // Creamos una fábrica de productos tipo 2
        IAbstractFactory fabrica2 = new ConcreteFactory2();

        // Uso la fábrica para crear productos de tipo A y B
        IProductA productoA2 = fabrica2.CrearProductoA();
        IProductB productoB2 = fabrica2.CrearProductoB();

        // Uso los productos
        productoA2.MetodoA();
        productoB2.MetodoB();
    }
}

En este ejemplo, el patrón Abstract Factory se utiliza para crear familias de objetos relacionados sin especificar sus clases concretas.

La interfaz IAbstractFactory define métodos para crear productos de tipo A y B. Luego, tenemos las implementaciones concretas ConcreteFactory1 y ConcreteFactory2, cada una de las cuales crea una familia específica de productos.

Cada familia de productos consiste en un conjunto de productos relacionados (por ejemplo, ConcreteProductA1 y ConcreteProductB1 para ConcreteFactory1).

Los clientes pueden utilizar una fábrica concreta para crear productos de una familia específica sin preocuparse por los detalles de su implementación, lo que promueve la independencia entre el código cliente y las clases concretas.

Los patrones de diseño estructurales desempeñan un papel crucial en la organización y estructura de nuestro código, permitiéndonos componer objetos de manera efectiva para lograr funcionalidades complejas y robustas.

El patrón de diseño Adapter destaca por su capacidad para permitir que dos interfaces incompatibles colaboren juntas.

Esta receta se utiliza para hacer que una clase existente sea compatible con una interfaz que de otro modo no podría interactuar con ella.

Este patrón es especialmente útil cuando se integran sistemas heredados con nuevos componentes.

Ejemplo de un patrón de diseño Adapter utilizando el lenguaje de programación C#:

using System;

// Interfaz existente que representa la funcionalidad esperada
public interface ITarget
{
    void Request();
}

// Clase existente que implementa la interfaz ITarget
public class ConcreteTarget : ITarget
{
    public void Request()
    {
        Console.WriteLine("Llamada a Request en ConcreteTarget");
    }
}

// Nueva interfaz que representa la funcionalidad que necesitamos adaptar
public interface IAdaptee
{
    void SpecificRequest();
}

// Clase existente que implementa la interfaz IAdaptee
public class Adaptee : IAdaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Llamada a SpecificRequest en Adaptee");
    }
}

// Adaptador que implementa la interfaz ITarget y utiliza un objeto de la clase Adaptee
public class Adapter : ITarget
{
    private readonly IAdaptee _adaptee;

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

    public void Request()
    {
        _adaptee.SpecificRequest();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Utilizando el objeto ConcreteTarget directamente
        ITarget target = new ConcreteTarget();
        target.Request(); // Salida: Llamada a Request en ConcreteTarget

        // Utilizando el Adapter para adaptar la funcionalidad de Adaptee
        IAdaptee adaptee = new Adaptee();
        ITarget adapter = new Adapter(adaptee);
        adapter.Request(); // Salida: Llamada a SpecificRequest en Adaptee
    }
}

En este ejemplo, tenemos una interfaz ITarget que representa la funcionalidad esperada por el cliente. La clase ConcreteTarget implementa esta interfaz.

También tenemos una interfaz IAdaptee que representa la funcionalidad existente que queremos adaptar. La clase Adaptee implementa esta interfaz.

Luego, creamos un adaptador (Adapter) que implementa la interfaz ITarget. El adaptador contiene una referencia a un objeto de la clase Adaptee. Cuando se llama al método Request() en el adaptador, internamente invoca el método SpecificRequest() del objeto Adaptee.

En el método Main, primero utilizamos el objeto ConcreteTarget directamente. Luego, utilizamos el adaptador para adaptar la funcionalidad de Adaptee a través de la interfaz ITarget, permitiendo así que el cliente utilice Adaptee como si fuera un ITarget.

El patrón Decorator nos permite agregar nuevas funcionalidades a objetos existentes sin alterar su estructura básica. Imagina tener una clase base y poder decorarla con características adicionales según sea necesario.

Este patrón es valioso para situaciones en las que se requiere una variedad de combinaciones de funcionalidades.

Ejemplo de código en C# utilizando el patrón de diseño Decorator:

using System;

// Interfaz componente que define la operación base
public interface IComponent
{
    void Operation();
}

// Implementación concreta de componente
public class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("Operación de ConcreteComponent");
    }
}

// Decorador abstracto que implementa la misma interfaz que el componente
public abstract class Decorator : IComponent
{
    protected IComponent component;

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

    public virtual void Operation()
    {
        if (component != null)
        {
            component.Operation();
        }
    }
}

// Decorador concreto que agrega funcionalidad antes de la operación base
public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component) : base(component) { }

    public override void Operation()
    {
        Console.WriteLine("Funcionalidad extra de ConcreteDecoratorA");
        base.Operation();
    }
}

// Otro decorador concreto que agrega funcionalidad después de la operación base
public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(IComponent component) : base(component) { }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("Funcionalidad extra de ConcreteDecoratorB");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Creamos un componente concreto
        IComponent component = new ConcreteComponent();

        // Decoramos el componente con ConcreteDecoratorA y luego con ConcreteDecoratorB
        component = new ConcreteDecoratorA(component);
        component = new ConcreteDecoratorB(component);

        // Llamamos a la operación y ahora incluye la funcionalidad extra de los decoradores
        component.Operation();
    }
}

En este ejemplo, tenemos una interfaz IComponent que define la operación base que será decorada. La clase ConcreteComponent implementa esta interfaz y proporciona la implementación base de la operación.

Luego, tenemos un decorador abstracto Decorator que implementa la misma interfaz que IComponent. Esta clase contiene una referencia al componente que será decorado y proporciona una implementación por defecto de la operación que simplemente llama a la operación del componente.

Después, tenemos decoradores concretos ConcreteDecoratorA y ConcreteDecoratorB que extienden el decorador abstracto. Cada decorador agrega funcionalidad antes o después de llamar a la operación del componente.

En el método Main, creamos un componente concreto y lo decoramos con ConcreteDecoratorA y luego con ConcreteDecoratorB. Cuando llamamos a la operación en el componente decorado, la funcionalidad adicional de los decoradores se ejecutará en orden.

El patrón de diseño Composite nos permite componer objetos en estructuras jerárquicas y tratar objetos individuales y compuestos de manera uniforme.

Esto significa que puedes manipular un objeto individual o un grupo de objetos compuestos de manera consistente.

Para entenderlo mejor a continuación tenéis un ejemplo de código del patrón en C#:

using System;
using System.Collections.Generic;

// Componente base que define la interfaz común para los nodos del árbol
public abstract class Component
{
    protected string name;

    public Component(string name)
    {
        this.name = name;
    }

    public abstract void Operation();
}

// Clase hoja que representa los nodos terminales del árbol
public class Leaf : Component
{
    public Leaf(string name) : base(name) { }

    public override void Operation()
    {
        Console.WriteLine($"Operación de la hoja {name}");
    }
}

// Clase compuesta que puede contener hojas o nodos compuestos como hijos
public class Composite : Component
{
    private List<Component> children = new List<Component>();

    public Composite(string name) : base(name) { }

    public void Add(Component component)
    {
        children.Add(component);
    }

    public void Remove(Component component)
    {
        children.Remove(component);
    }

    public override void Operation()
    {
        Console.WriteLine($"Operación del nodo compuesto {name}");

        foreach (var child in children)
        {
            child.Operation();
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Creamos un árbol compuesto
        Composite root = new Composite("Root");
        Composite branch1 = new Composite("Branch 1");
        Composite branch2 = new Composite("Branch 2");
        Leaf leaf1 = new Leaf("Leaf 1");
        Leaf leaf2 = new Leaf("Leaf 2");
        Leaf leaf3 = new Leaf("Leaf 3");

        // Construimos la estructura del árbol
        root.Add(branch1);
        root.Add(branch2);
        branch1.Add(leaf1);
        branch1.Add(leaf2);
        branch2.Add(leaf3);

        // Llamamos a la operación del nodo raíz, 
        // que a su vez llama a las operaciones de sus hijos
        root.Operation();
    }
}

En este ejemplo, tenemos una clase Component que es la clase base para los nodos del árbol. Tiene un método abstracto Operation() que será implementado por las clases hoja y compuesta.

La clase Leaf representa los nodos hoja del árbol, es decir, los nodos terminales sin hijos.

La clase Composite representa los nodos compuestos que pueden contener otros nodos (hojas o compuestos) como hijos. Tiene una lista de hijos y métodos para agregar y eliminar hijos, además de implementar el método Operation() que llama a la operación de cada uno de sus hijos.

En el método Main, creamos un árbol compuesto con varios niveles de profundidad y llamamos a la operación del nodo raíz. Esta operación se propaga a través del árbol, ejecutando las operaciones de todos los nodos.

Los patrones de diseño de comportamiento actúan como guías estratégicas que definen cómo los objetos interactúan y se comunican, influyendo en el flujo de ejecución y el comportamiento general de una aplicación.

El patrón de diseño Observer se basa en el principio de suscripción y notificación. Permite que un objeto mantenga a otros objetos (los observadores) informados sobre cualquier cambio en su estado.

Cuando el objeto cambia, todos los observadores son notificados y actualizados automáticamente.

A continuación tenéis un ejemplo de código en C# para entender mejor el patrón Observer:

// Interfaz del Observer
public interface IObserver
{
    void Update();
}

// Clase concreta del Observer
public class ConcreteObserver : IObserver
{
    public void Update()
    {
        Console.WriteLine("El Observer ha sido notificado.");
    }
}

// Interfaz del Sujeto
public interface ISubject
{
    void RegisterObserver(IObserver observer);
    void RemoveObserver(IObserver observer);
    void NotifyObservers();
}

// Clase concreta del Sujeto
public class ConcreteSubject : ISubject
{
    private List<IObserver> _observers = new List<IObserver>();

    public void RegisterObserver(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void RemoveObserver(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void NotifyObservers()
    {
        foreach (var observer in _observers)
        {
            observer.Update();
        }
    }
}

En este ejemplo, IObserver es la interfaz que implementan todos los observadores, que deben tener un método Update(). ConcreteObserver es una implementación concreta de un observador.

Por otro lado, ISubject es la interfaz que implementa el sujeto, que puede registrar, eliminar y notificar a los observadores. ConcreteSubject es una implementación concreta de un sujeto.

Para usar este código, primero debes crear una instancia de ConcreteSubject. Luego, puedes registrar observadores con el método RegisterObserver().

Cuando ocurra un evento que requiera notificar a los observadores, puedes llamar al método NotifyObservers() del sujeto.

El patrón de diseño Strategy se enfoca en encapsular diferentes algoritmos en objetos separados y permitir que se intercambien fácilmente.

Esto significa que puedes cambiar el comportamiento de un objeto simplemente cambiando la estrategia que está utilizando.

Por ejemplo, en una aplicación de procesamiento de pagos, podrías implementar estrategias diferentes para diferentes métodos de pago (tarjeta de crédito, PayPal, etc.).

Un ejemplo práctico del patrón de diseño Strategy utilizando C# puede ser el siguiente:

// Interfaz de la estrategia
public interface IStrategy
{
    void Execute();
}

// Estrategias concretas
public class ConcreteStrategyA : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("Ejecutando estrategia A");
    }
}

public class ConcreteStrategyB : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("Ejecutando estrategia B");
    }
}

// Contexto
public class Context
{
    private IStrategy _strategy;

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

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

    public void ExecuteStrategy()
    {
        _strategy.Execute();
    }
}

En este ejemplo, IStrategy es la interfaz que implementan todas las estrategias, que deben tener un método Execute(). ConcreteStrategyA y ConcreteStrategyB son implementaciones concretas de estrategias.

Por otro lado, Context es la clase que utiliza una estrategia. Puede cambiar la estrategia en tiempo de ejecución con el método SetStrategy() y ejecutar la estrategia con el método ExecuteStrategy().

Para usar este código, primero debes crear una instancia de Context con una estrategia inicial. Luego, puedes cambiar la estrategia con el método SetStrategy() y ejecutar la estrategia con el método ExecuteStrategy().

El patrón de diseño Command se centra en encapsular una solicitud como un objeto, lo que permite parametrizar diferentes solicitudes y encolarlas para su ejecución.

Esto se traduce en la capacidad de desacoplar el invocador de la acción real, lo que facilita la implementación de características como deshacer/rehacer y el registro de acciones.

Aquí tenéis un ejemplo en C# del patrón de diseño Command para entenderlo mejor:

// Interfaz del Command
public interface ICommand
{
    void Execute();
}

// Comando concreto
public class ConcreteCommand : ICommand
{
    private Receiver _receiver;

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

    public void Execute()
    {
        _receiver.Action();
    }
}

// Clase Receiver
public class Receiver
{
    public void Action()
    {
        Console.WriteLine("Acción ejecutada por el receiver.");
    }
}

// Clase Invoker
public class Invoker
{
    private ICommand _command;

    public void SetCommand(ICommand command)
    {
        _command = command;
    }

    public void ExecuteCommand()
    {
        _command.Execute();
    }
}

En este ejemplo, ICommand es la interfaz que implementan todos los comandos, que deben tener un método Execute(). ConcreteCommand es una implementación concreta de un comando.

Por otro lado, Receiver es la clase que realiza la acción cuando se ejecuta el comando.

Finalmente, Invoker es la clase que invoca el comando. Puede cambiar el comando en tiempo de ejecución con el método SetCommand() y ejecutar el comando con el método ExecuteCommand().

Para usar este código, primero debes crear una instancia de Receiver y ConcreteCommand. Luego, puedes crear una instancia de Invoker, asignarle el comando con el método SetCommand() y finalmente ejecutar el comando con el método ExecuteCommand().

En este artículo hemos explorado los fundamentos de los diferentes patrones de diseño, su aplicación en C# y las mejores prácticas para su implementación.

A medida que avances en tu carrera como experto de desarrollo de software, recuerda que los patrones de diseño son herramientas que pueden impulsar tu creatividad y eficiencia. Combina la teoría con la práctica, mantente actualizado con las últimas tendencias y ¡nunca dejes de aprender!

¡Hasta la próxima!