¿Qué es un mediador en el contexto de la…

El mediador es un patrón de diseño de comportamiento que propone un objeto centralizado para gestionar la interacción entre otros objetos (colegas). En lugar de comunicarse directamente entre sí, los objetos interactúan a través del mediador.

Ventajas del uso del mediador:

Reducción del acoplamiento: Los objetos no tienen referencias directas entre sí, lo que disminuye su dependencia.
Simplificación de la gestión: Las interacciones entre objetos se concentran en un solo lugar, facilitando su comprensión y modificación.
Mejora de la reutilización: Los componentes individuales pueden reutilizarse en otros contextos, ya que no están fuertemente ligados a otros componentes del sistema.

Desventajas:

Aumento de la complejidad del mediador: A medida que aumentan las interacciones, el mediador puede volverse complejo y difícil de mantener.
Posible disminución del rendimiento: Todas las interacciones pasan por un objeto central, lo que puede generar costos adicionales.

Ejemplo de implementación sencilla:

// Interfaz para el mediador
public interface IMediator
{
    void SendMessage(string message, Colleague colleague);
}

// Clase base para colegas
public abstract class Colleague
{
    protected IMediator mediator;

    public Colleague(IMediator mediator)
    {
        this.mediator = mediator;
    }

    public abstract void ReceiveMessage(string message);
    public abstract void Send(string message);
}

// Mediador concreto
public class ConcreteMediator : IMediator
{
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

    public ConcreteColleague1 Colleague1
    {
        set { colleague1 = value; }
    }

    public ConcreteColleague2 Colleague2
    {
        set { colleague2 = value; }
    }

    public void SendMessage(string message, Colleague colleague)
    {
        if (colleague == colleague1)
        {
            colleague2.ReceiveMessage(message);
        }
        else
        {
            colleague1.ReceiveMessage(message);
        }
    }
}

// Colegas concretos
public class ConcreteColleague1 : Colleague
{
    public ConcreteColleague1(IMediator mediator) : base(mediator) { }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Mensaje recibido por Colega 1: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Mensaje enviado por Colega 1: {message}");
        mediator.SendMessage(message, this);
    }
}

public class ConcreteColleague2 : Colleague
{
    public ConcreteColleague2(IMediator mediator) : base(mediator) { }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Mensaje recibido por Colega 2: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Mensaje enviado por Colega 2: {message}");
        mediator.SendMessage(message, this);
    }
}

// Ejemplo de uso
// var mediator = new ConcreteMediator();
// var colleague1 = new ConcreteColleague1(mediator);
// var colleague2 = new ConcreteColleague2(mediator);
// mediator.Colleague1 = colleague1;
// mediator.Colleague2 = colleague2;
// colleague1.Send("¡Hola Colega 2!");
// colleague2.Send("¡Hola Colega 1!");

Se usa a menudo junto con otros patrones, como Observer, para implementar sistemas de intercambio de mensajes más complejos. En el contexto de .NET, se aplica frecuentemente en bibliotecas para trabajar con solicitudes y comandos, como MediatR.

¿Qué es un mediador en el contexto de la programación?