C# Design Pattern: Mediator (Portugues)

O padrão Mediator é usado para reduzir as dependências diretas entre os objetos ao introduzir um objeto mediador que controla a comunicação entre eles. Isso é útil quando você tem muitos objetos que precisam se comunicar entre si, mas não quer que eles estejam fortemente acoplados uns aos outros. O Mediator centraliza essa comunicação, tornando o código mais flexível e fácil de manter.

Exemplo de Código em C#:

// Interface do Mediador
public interface IMediador
{
    void EnviarMensagem(string mensagem, Colega colega);
}

// Classe base para colegas que se comunicam através do mediador
public abstract class Colega
{
    protected IMediador _mediador;

    public Colega(IMediador mediador)
    {
        _mediador = mediador;
    }

    public abstract void ReceberMensagem(string mensagem);
}

// Colega Concreto 1
public class ColegaConcreto1 : Colega
{
    public ColegaConcreto1(IMediador mediador) : base(mediador) { }

    public void Enviar(string mensagem)
    {
        Console.WriteLine($"Colega 1 enviando mensagem: {mensagem}");
        _mediador.EnviarMensagem(mensagem, this);
    }

    public override void ReceberMensagem(string mensagem)
    {
        Console.WriteLine($"Colega 1 recebeu mensagem: {mensagem}");
    }
}

// Colega Concreto 2
public class ColegaConcreto2 : Colega
{
    public ColegaConcreto2(IMediador mediador) : base(mediador) { }

    public void Enviar(string mensagem)
    {
        Console.WriteLine($"Colega 2 enviando mensagem: {mensagem}");
        _mediador.EnviarMensagem(mensagem, this);
    }

    public override void ReceberMensagem(string mensagem)
    {
        Console.WriteLine($"Colega 2 recebeu mensagem: {mensagem}");
    }
}

// Mediador Concreto que gerencia a comunicação
public class MediadorConcreto : IMediador
{
    private ColegaConcreto1 _colega1;
    private ColegaConcreto2 _colega2;

    public ColegaConcreto1 Colega1
    {
        set { _colega1 = value; }
    }

    public ColegaConcreto2 Colega2
    {
        set { _colega2 = value; }
    }

    public void EnviarMensagem(string mensagem, Colega colega)
    {
        if (colega == _colega1)
        {
            _colega2.ReceberMensagem(mensagem);
        }
        else
        {
            _colega1.ReceberMensagem(mensagem);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Criar o mediador
        MediadorConcreto mediador = new MediadorConcreto();

        // Criar colegas
        ColegaConcreto1 colega1 = new ColegaConcreto1(mediador);
        ColegaConcreto2 colega2 = new ColegaConcreto2(mediador);

        // Definir colegas no mediador
        mediador.Colega1 = colega1;
        mediador.Colega2 = colega2;

        // Colega 1 envia uma mensagem
        colega1.Enviar("Olá do Colega 1");

        // Colega 2 envia uma mensagem
        colega2.Enviar("Oi do Colega 2");
    }
}

Explicação do Código:

Neste exemplo, o MediadorConcreto gerencia a comunicação entre dois colegas, ColegaConcreto1 e ColegaConcreto2. Quando um colega envia uma mensagem, o mediador decide para qual colega a mensagem será enviada. Isso reduz o acoplamento direto entre os colegas, já que eles não precisam saber sobre a existência um do outro, apenas do mediador.

Conclusão:

O padrão Mediator é útil quando você quer centralizar a comunicação entre vários objetos, evitando que eles fiquem diretamente acoplados. Isso torna o código mais modular e fácil de modificar, pois você pode mudar a lógica de comunicação sem alterar os objetos individuais.

Código fonte: GitHub