использование командных и фабричных шаблонов проектирования для выполнения заданий в очереди

Большинство реализаций шаблонов команд C# более или менее совпадают с реализацией Java. Эти реализации обычно используют интерфейс ICommand:

public interface ICommand
{
    void Execute();
}

и тогда все классы команд вынуждены реализовывать интерфейс. У меня нет проблем с этим решением, но лично мне не нравится создавать слишком много классов, и вместо этого я предпочитаю использовать делегатов .NET (в Java нет делегатов). Делегат Action обычно помогает, если нужна только одна ссылка на метод:

public class Prog
{
    public Prog()
    {
        var factory = new CommandFactory();
        factory.Register("A", () => new A().DoA);            
        factory.Register("B", () => new B().DoB);
        factory.Register("C", DoStuff);

        factory.Execute("A");
    }

  public static void DoStuff()
    {
    }
}

public class CommandFactory
{
    private readonly IDictionary<string, Action> _commands;       

    public void Register(string commandName, Action action)
    {
    _commands.Add(commandName, action); 
    }

    public Action GetCommand(string commandName)
    {
        _commands[commandName];
    }

    public void Execute(string commandName)
    {
        GetCommand(commandName)();
    }
}
public class A
{
    public void DoA()
    {
    }
}

public class B
{
    public void DoB()
    {
    }
}

Если вашему командному интерфейсу требуется более одного метода, например:

public interface ICommand
{
    void Execute();
    void Undo();
}

Вы можете использовать класс-оболочку следующим образом:

public class Command
{
    public Command(Action execute, Action undo)
    {
        Execute = execute;
        Undo = undo;
    }

    public Action Execute { get; protected set; }
    public Action Undo { get; protected set; }
}

или (неважно какой)

public class Command 
{
    private readonly Action _execute;
    private readonly Action _undo;

    public Command(Action execute, Action undo)
    {
        _execute = execute;
        _undo = undo;
    }

    public void Execute()
    {
        _execute();
    }

    public void Undo()
    { 
        _undo();
    }
}

(это может даже реализовать ICommand, если у вас уже есть устаревшие вещи, использующие его. Если вы используете интерфейс, фабрика должна использовать интерфейс вместо класса Command)

С такой оболочкой вам не нужно создавать класс команд для каждого действия, которое вы хотите поддерживать. В следующем примере показано, как можно использовать класс-оболочку:

public class Prog2
{
    public Prog2()
    {
        var factory = new CommandFactory2();
        factory.Register("A", new Lazy<Command>(
            ()=>
                {
                    var a = new A();
                    return new Command(a.DoA, a.UndoA);
                }));

        factory.Register("B", new Lazy<Command>(
           () =>
           {
               var c = new B();
               return new Command(c.DoB, c.DoB);
           }));

        factory.Register("C", new Lazy<Command>(
            () => new Command(DoStuff, UndoStuff)));

        factory.Execute("A");
    }

    public static void DoStuff()
    {
    }

    public static void UndoStuff()
    {
    }
}

public class CommandFactory2
{
    private readonly IDictionary<string, Lazy<Command>> _commands;

    public void Register(string commandName, Lazy<Command> lazyCommand)
    {
        _commands.Add(commandName, lazyCommand);
    }

    public void Register(string commandName, Action execute, Action undo)
    {
        _commands.Add(commandName, new Lazy<Command>(() => new Command(execute, undo)));
    }

    public Command GetCommand(string commandName)
    {
        return _commands[commandName].Value;
    }

    public void Execute(string commandName)
    {
        GetCommand(commandName).Execute();
    }

    public void Undo(string commandName)
    {
        GetCommand(commandName).Undo();
    }
}


public class A
{
    public void DoA()
    {
    }

    public void UndoA()
    {
    }
}

public class B
{
    public void DoB()
    {
    }

    public void UndoB()
    {
    }
}

Как видите, нет необходимости реализовывать интерфейс, даже если у вас есть более одного метода (Execute, Undo и т. д.). Обратите внимание, что методы Execute и Undo могут принадлежать к разным классам. Вы можете структурировать свой код так, как он кажется более естественным, и по-прежнему можете использовать шаблон команды.

Вы можете использовать Dictionary для сопоставления буквы/символа с соответствующей реализацией ICommand. Что-то типа:

public class CommandFactory
{
    private readonly Dictionary<string, ICommand> mCommands = new Dictionary<string,ICommand>(StringComparer.OrdinalIgnoreCase);

    public void RegisterCommand<TCommand>(string commandKey) where TCommand : ICommand, new()
    {
        // Instantiate the command
        ICommand command = new TCommand();

        // Add to the collection
        mCommands.Add(commandKey, command);
    }

    public void ExecuteCommand(string commandKey)
    {
        // See if the command exists
        ICommand command;
        if (!mCommands.TryGetValue(commandKey, out command))
        {
            // TODO: Handle invalid command key
        }

        // Execute the command
        command.Execute();
    }
}

Используя это, вы можете регистрировать типы команд и сопоставлять их с ключами на основе string, а также разрешать их создание и выполнение более общим образом. Вы можете повысить производительность, создав экземпляры команд только при их первом использовании.

ИЗМЕНИТЬ

В ответ на ваш комментарий, чтобы создавать экземпляры только при выполнении, вы можете сделать что-то вроде:

public class CommandDetails<T> where T : ICommand, new()
{
    private ICommand mCommand;

    public ICommand GetCommand()
    {
        if (/* Determine if the command has been instantiated */)
        {
            // Instantiate the command
            mCommand = new T();
        }

        return mCommand;
    }
}

public void ExecuteCommand(...)
{
    // See if the command exists
    CommandDetails details;
    // ...

    // Get the command
    // Note: If we haven't got the command yet, this will instantiate it for us.
    ICommand command = details.GetCommand();

    // ...
}

Вы можете попросить свою работу предоставить собственную команду ICommand:

interface IJob 
{
  ICommand Command { get; }
}

public class JobA : IJob
{
  private readonly ICommand _command = new CommandA();
  public ICommand Command { get { return _command; } }
}

Тогда вместо включения jobCode вы можете просто сделать:

job.Command.Execute();