1. Comando (Command):  Declara uma interface para executar uma operação; Esta classe abstrata é a classe base para todos os objetos Command. A classe também define um método abstrato que é usado pelo Chamador para executar comandos.
2. ComandoConcreto (CommandConcret): Define uma vinculação entre um objeto Receptor e uma ação; Além de implementar o método Execute, ela contém todas as informações que são necessárias para executar corretamente a ação usando o objeto Receptor vinculado.
3. Cliente (Client) - Cria um objeto ComandoConcreto e define o seu receptor; É o consumidor das classes do padrão Command;
4. Chamador(Invoker) - Solicita ao comando para executar a requisição; Inicia a execução dos comandos;
5. Receptor(Receiver) - Conhece como executar as operações associadas com a execução do comando; Objetos receptores contém os métodos que são executados quando um ou mais comandos são invocados. Isso permite que a funcionalidade real seja realizada separadamente para as definições de comando.

namespace PadraoProjetoCommand
{
    public abstract class RoboCommand
    {
       protected Robo _robo;

       public RoboCommand(Robo robo)
       {
           _robo = robo;
       }
 
       public abstract void Executar();
       public abstract void Desfazer();
    }
}

Public MustInherit Class RoboCommand
    Protected _robo As Robo

    Public Sub New(robo As Robo)
        _robo = robo
    End Sub

    Public MustOverride Sub Executar()
    Public MustOverride Sub Desfazer()
End Class

namespace PadraoProjetoCommand
{
    class MoverCommand : RoboCommand
    {
        public int ParaFrente { get; set; }
        public MoverCommand(Robo robo) : base(robo) { }

        public override void Executar()
        {
            _robo.Mover(ParaFrente);
        }

        public override void Desfazer()
        {
            _robo.Mover(-ParaFrente);
        }
    }
}

Class MoverCommand
    Inherits RoboCommand

    Public Property ParaFrente() As Integer
        Get
            Return m_ParaFrente
        End Get
        Set(value As Integer)
            m_ParaFrente = Value
        End Set
    End Property
    Private m_ParaFrente As Integer
    Public Sub New(robo As Robo)
        MyBase.New(robo)
    End Sub

    Public Overrides Sub Executar()
        _robo.Mover(ParaFrente)
    End Sub

    Public Overrides Sub Desfazer()
        _robo.Mover(-ParaFrente)
    End Sub
End Class

namespace PadraoProjetoCommand
{
    class RotacionarCommand: RoboCommand
    {
        public double rotacionarParaEsquerda { get; set; }
        public RotacionarCommand(Robo robo) : base(robo) { }
 
        public override void Executar()
        {
            _robo.RotacionarParaEsquerda(rotacionarParaEsquerda);
        }
 
        public override void Desfazer()
        {
            _robo.RotacionarParaEsquerda(-rotacionarParaEsquerda);
        }
    }
}

Class RotacionarCommand
    Inherits RoboCommand

    Public Property rotacionarParaEsquerda() As Double
        Get
            Return m_rotacionarParaEsquerda
        End Get
        Set(value As Double)
            m_rotacionarParaEsquerda = Value
        End Set
    End Property
    Private m_rotacionarParaEsquerda As Double
    Public Sub New(robo As Robo)
        MyBase.New(robo)
    End Sub

    Public Overrides Sub Executar()
        _robo.RotacionarParaEsquerda(rotacionarParaEsquerda)
    End Sub

    Public Overrides Sub Desfazer()
        _robo.RotacionarParaEsquerda(-rotacionarParaEsquerda)
    End Sub
End Class

namespace PadraoProjetoCommand
{
    class EscavarCommand : RoboCommand
    {
        public bool ColherMaterial { get; set; }

        public EscavarCommand(Robo robo) : base(robo) { }
 
        public override void Executar()
        {
            _robo.Escavar(ColherMaterial);
        }
 
        public override void Desfazer()
        {
            _robo.Escavar(!ColherMaterial);
        }
    }
}

Class EscavarCommand
    Inherits RoboCommand
    Public Property ColherMaterial() As Boolean
        Get
            Return m_ColherMaterial
        End Get
        Set(value As Boolean)
            m_ColherMaterial = Value
        End Set
    End Property
    Private m_ColherMaterial As Boolean

    Public Sub New(robo As Robo)
        MyBase.New(robo)
    End Sub

    Public Overrides Sub Executar()
        _robo.Escavar(ColherMaterial)
    End Sub

    Public Overrides Sub Desfazer()
        _robo.Escavar(Not ColherMaterial)
    End Sub
End Class

using System;

namespace PadraoProjetoCommand
{
    class Robo
    {
        public void Mover(int ParaFrente)
        {
            if (ParaFrente > 0)
                Console.WriteLine("O Robo foi movimentado para frente {0}mm.", ParaFrente);
            else
                Console.WriteLine("O Robo foi movimentado para trás {0}mm.", -ParaFrente);
        }

        public void RotacionarParaEsquerda(double rotacionarParaEsquerda)
        {
            if (rotacionarParaEsquerda > 0)
                Console.WriteLine("O Robo foi rotacionaod para esquerda {0} degrees.", rotacionarParaEsquerda);
            else
                Console.WriteLine("O Robo foi rotacionado para direita {0} degrees.", -rotacionarParaEsquerda);
        }

        public void Escavar(bool paraCima)
        {
            if (paraCima)
                Console.WriteLine("O Robo colheu material do solo.");
            else
                Console.WriteLine("O Robo despejou o material colhido.");
        }
    }
}

Class Robo
    Public Sub Mover(ParaFrente As Integer)
        If ParaFrente > 0 Then
            Console.WriteLine("O Robo foi movimentado para frente {0}mm.", ParaFrente)
        Else
            Console.WriteLine("O Robo foi movimentado para trás {0}mm.", -ParaFrente)
        End If
    End Sub

    Public Sub RotacionarParaEsquerda(rotacionarParaEsquerda__1 As Double)
        If rotacionarParaEsquerda__1 > 0 Then
            Console.WriteLine("O Robo foi rotacionaod para esquerda {0} degrees.", rotacionarParaEsquerda__1)
        Else
            Console.WriteLine("O Robo foi rotacionado para direita {0} degrees.", -rotacionarParaEsquerda__1)
        End If
    End Sub

    Public Sub Escavar(paraCima As Boolean)
        If paraCima Then
            Console.WriteLine("O Robo colheu material do solo.")
        Else
            Console.WriteLine("O Robo despejou o material colhido.")
        End If
    End Sub
End Class

using System;
using System.Collections.Generic;

namespace PadraoProjetoCommand
{
    class RoboControle
    {
        public Queue<RoboCommand> Comandos;
        private Stack<RoboCommand> _desfazerPilha;
 
        public RoboControle()
        {
            Comandos = new Queue<RoboCommand>();
            _desfazerPilha = new Stack<RoboCommand>();
        }
 
        public void ExecutarComandos()
        {
            Console.WriteLine("EXECUTANDO COMANDO(S).");
 
            while (Comandos.Count > 0)
            {
                RoboCommand comando = Comandos.Dequeue();
                comando.Executar();
                _desfazerPilha.Push(comando);
            }
        }
 
        public void DesfazerComandos(int numComandosDesfazer)
        {
            Console.WriteLine("DESFAZENDO {0} COMANDO(S).", numComandosDesfazer);

            while (numComandosDesfazer > 0 && _desfazerPilha.Count > 0)
            {
                RoboCommand comand = _desfazerPilha.Pop();
                comand.Desfazer();
                numComandosDesfazer--;
            }
        }
    }
}

Class RoboControle
	Public Comandos As Queue(Of RoboCommand)
	Private _desfazerPilha As Stack(Of RoboCommand)

	Public Sub New()
		Comandos = New Queue(Of RoboCommand)()
		_desfazerPilha = New Stack(Of RoboCommand)()
	End Sub

	Public Sub ExecutarComandos()
		Console.WriteLine("EXECUTANDO COMANDO(S).")

		While Comandos.Count > 0
			Dim comando As RoboCommand = Comandos.Dequeue()
			comando.Executar()
			_desfazerPilha.Push(comando)
		End While
	End Sub

	Public Sub DesfazerComandos(numComandosDesfazer As Integer)
		Console.WriteLine("DESFAZENDO {0} COMANDO(S).", numComandosDesfazer)

		While numComandosDesfazer > 0 AndAlso _desfazerPilha.Count > 0
			Dim comand As RoboCommand = _desfazerPilha.Pop()
			comand.Desfazer()
			numComandosDesfazer -= 1
		End While
	End Sub
End Class

using System;
namespace PadraoProjetoCommand
{
    class Program
    {
        static void Main(string[] args)
        {

            Robo robo = new Robo();
            RoboControle controle = new RoboControle();

            MoverCommand mover = new MoverCommand(robo);
            mover.ParaFrente = 1000;
            controle.Comandos.Enqueue(mover);

            RotacionarCommand rotacionar = new RotacionarCommand(robo);
            rotacionar.rotacionarParaEsquerda = 45;
            controle.Comandos.Enqueue(rotacionar);

            EscavarCommand escavar = new EscavarCommand(robo);
            escavar.ColherMaterial = true;
            controle.Comandos.Enqueue(escavar);

            controle.ExecutarComandos();
            controle.DesfazerComandos(3);

            Console.ReadKey();
        }
    }
}

Module Module1

    Sub Main()
        Dim robo As New Robo()
        Dim controle As New RoboControle()

        Dim mover As New MoverCommand(robo)
        mover.ParaFrente = 1000
        controle.Comandos.Enqueue(mover)

        Dim rotacionar As New RotacionarCommand(robo)
        rotacionar.rotacionarParaEsquerda = 45
        controle.Comandos.Enqueue(rotacionar)

        Dim escavar As New EscavarCommand(robo)
        escavar.ColherMaterial = True
        controle.Comandos.Enqueue(escavar)

        controle.ExecutarComandos()
        controle.DesfazerComandos(3)

        Console.ReadKey()
    End Sub

End Module