O padrão Command é usado para encapsular uma solicitação como um objeto, permitindo que você parametrize clientes com diferentes solicitações, filas ou operações reversíveis. Ele é útil quando você quer separar a lógica de execução de comandos, por exemplo, em um editor de texto que permite desfazer e refazer ações, como copiar, colar ou excluir.

Exemplo de Código em C#:

// Interface para os comandos
public interface IComando
{
    void Executar();
}

// Classe que representa um receptor, ou seja, quem executa as ações reais
public class Luz
{
    public void Ligar()
    {
        Console.WriteLine("A luz está ligada.");
    }

    public void Desligar()
    {
        Console.WriteLine("A luz está desligada.");
    }
}

// Comando para ligar a luz
public class ComandoLigarLuz : IComando
{
    private Luz _luz;

    public ComandoLigarLuz(Luz luz)
    {
        _luz = luz;
    }

    public void Executar()
    {
        _luz.Ligar();
    }
}

// Comando para desligar a luz
public class ComandoDesligarLuz : IComando
{
    private Luz _luz;

    public ComandoDesligarLuz(Luz luz)
    {
        _luz = luz;
    }

    public void Executar()
    {
        _luz.Desligar();
    }
}

// O invocador, que chama os comandos
public class ControleRemoto
{
    private IComando _comando;

    public void DefinirComando(IComando comando)
    {
        _comando = comando;
    }

    public void PressionarBotao()
    {
        _comando.Executar();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Criar os objetos
        Luz luz = new Luz();
        IComando ligarLuz = new ComandoLigarLuz(luz);
        IComando desligarLuz = new ComandoDesligarLuz(luz);

        // Criar o invocador (controle remoto)
        ControleRemoto controle = new ControleRemoto();

        // Ligar a luz
        controle.DefinirComando(ligarLuz);
        controle.PressionarBotao();  // Saída: A luz está ligada.

        // Desligar a luz
        controle.DefinirComando(desligarLuz);
        controle.PressionarBotao();  // Saída: A luz está desligada.
    }
}

Explicação do Código:

Neste exemplo, o ControleRemoto é o invocador que chama comandos para ligar e desligar a luz. Os comandos ComandoLigarLuz e ComandoDesligarLuz encapsulam as ações de ligar e desligar a luz, e o controle remoto decide qual comando executar. Isso separa a lógica de execução do controle remoto da lógica específica de cada comando.

Conclusão:

O padrão Command é útil para encapsular ações como objetos independentes, permitindo maior flexibilidade para definir, substituir ou até mesmo desfazer operações. Ele separa o cliente que solicita a execução de uma ação do objeto que realiza essa ação.

Código fonte: GitHub

C# Design Pattern: Command (Portugues)