Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Implementing the Command Pattern using C# Action delegate

Is it possible implement the GOF command pattern using a Queue of Action delegates?

I have been trying to wrap my head around it for a while and I am stumped because each of the possible actions I want to add to the queue may have a varing number of parameters.

Any suggestions? Am I barking up the wrong tree by focusing on the command pattern?

UPDATE:

Many thanks jgauffin, it works a treat... my implementation now looks like

public class CommandDispatcher
{
    private readonly Dictionary<Type, List<Action<ICommand>>> _registeredCommands =
        new Dictionary<Type, List<Action<ICommand>>>();

    public void RegisterCommand<T>(Action<ICommand> action) where T : ICommand
    {
        if (_registeredCommands.ContainsKey(typeof (T)))
            _registeredCommands[typeof (T)].Add(action);
        else
            _registeredCommands.Add(typeof (T), new List<Action<ICommand>> {action});
    }

    public void Trigger<T>(T command) where T : ICommand
    {
        if (!_registeredCommands.ContainsKey(typeof(T)))
            throw new InvalidOperationException("There are no subscribers for that command");

        foreach (var registeredCommand in _registeredCommands[typeof(T)])
        {
            registeredCommand(command);
            if (command.Cancel) break;
        }
    }
}
like image 773
David Avatar asked Oct 11 '10 05:10

David


3 Answers

You can use an Action. You should not use multiple parameters. What happens if a command needs a new parameter? Then you would need to change all places invoking the command plus the handler.

Instead, you should use Command classes which has all parameters as properties. In this way you can add parameters without it affecting the code (the new parameters should be treated as optional in the handler).

this is how I would do it:

public interface ICommand
{
    // Cancel processing, do not invoke any more handlers
    public bool Cancel { get; set; }
}

public class CommandDispatcher 
{
  private Dictionary<Type, List<Action<ICommand>>> _commands = new Dictionary<Type, List<Action<ICommand>>>();


  // Add to dictionary here
  public void Subscribe<T>(Action<T> action) where T : ICommand
  {
      List<Action<ICommand>> subscribers;
      if (!_commands.TryGetValue(typeof(T), out subscribers))
      {
          subscribers = new List<Action<ICommand>>();
          _commands.Add(typeof(T), subscribers));
      }

      subscribers.Add(action);
  }

  // find command and to foreach to execute the actions      
  public void Trigger<T>(T command) where T : ICommand
  {
      List<Action<ICommand>> subscribers;
      if (!_commands.TryGetValue(typeof(T), out subscribers))
          throw new InvalidOperationException("There are no subscribers for that command");

      foreach(var subsriber in subscribers)
      {
          subscriber(command);
          if (command.Cancel)
              break; //a handler canceled the command to prevent others from processing it.
      }
  }

}

public class AddTextCommand : ICommand
{
    public string TextToAdd {get;set;}
}

public class TextHandler
{
    public TextHandler(CommandDispatcher dispatcher)
    {
        disptacher.Subscribe<AddTextCommand>(OnAddText);
    }

    public void OnAddText(AddTextCommand cmd)
    {
        //....
    }
}


public partial class MyForm : Form
{
    CommandDispatcher _dispatcher;

    private void MyTextBox_Changed(object source, EventArgs e)
    {
        _dispatcher.Trigger(new AddTextCommand{TextToAdd = MyTextBox.Text}=;
    } 
}

Note that the code is kind of pseudo-code. I've written it directly in the answer without testing it. You will probably have to change stuff in order to get it working, but it should at least give you a hint. The implementation let's you add multiple subscribers for each command.

like image 119
jgauffin Avatar answered Oct 20 '22 06:10

jgauffin


In command pattern, typical command interface would have simple execute method - this can be represented by Action delegate. But actual implementation will be provided by different concrete classes where you will/can pass parameters (for example, via constructor). For example:

public interface ICommand 
{
   public void Execute();
}

public class Command1 : ICommand
{
   public Command1(int param1, string param2)
   {
   }

   ...
}

public class Command2 : ICommand
{
  ...
}

public class Program
{

   public static void Main()
   {

       ...

       var commands = new List<Action>();
       commands.Add((new Command1(3, "Hello")).Execute);
       commands.Add((new Command2(...)).Execute);

       ...
   }


}

The point here is that command related state and implementation would be encapsulated within different implementation while Action delegate will point to its instance method. So invoking the delegate will result in execution of the command.

like image 37
VinayC Avatar answered Oct 20 '22 06:10

VinayC


If you're concerned with the number of parameters, then properly implementing the command pattern using a class would be the right way to go. The Action delegate is limited to only one. Also, if you use the Action delegate, you might want to implement an Undo later on which you won't be able to do since you just used a delegate instead of a class.

like image 35
Jonn Avatar answered Oct 20 '22 06:10

Jonn