O que é um mediador no contexto da programação?

O mediador é um padrão de design comportamental que propõe um objeto centralizado para gerir a interação entre outros objetos (colegas). Em vez de comunicarem diretamente, os objetos interagem através do mediador.

Vantagens do uso do mediador:

• Redução do acoplamento: Os objetos não têm referências diretas uns aos outros, o que diminui a dependência.
• Simplificação da gestão: As interações entre objetos são concentradas num só lugar, facilitando a compreensão e alteração.
• Melhoria da reutilização: Componentes individuais podem ser reutilizados em outros contextos.

Desvantagens:

• Aumento da complexidade do mediador: Com o aumento das interações, o mediador pode tornar-se complexo e difícil de manter.
• Potencial impacto na performance: Todas as interações passam por um objeto central, o que pode gerar custos adicionais.

Exemplo de implementação simples:

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

// Classe 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($"Mensagem recebida por Colega 1: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Mensagem enviada 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($"Mensagem recebida por Colega 2: {message}");
    }

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

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

Frequentemente utilizado em conjunto com outros padrões, como o Observer, para sistemas de troca de mensagens mais complexos. No contexto do .NET, é comum em bibliotecas de trabalho com requisições e comandos, como o MediatR.