Digging through SignalR - Commands

Looking over source code of SignalR. I found some interesting class and ways to implement different behaviors. In the next series of post I will share with you what I found interesting.
Before starting, you should know that SignalR is an open source project that can be accessed using GitHub.
In today post we will talk about command pattern. This patterns over the ability to define a “macro”/command that can be executed without knowing the caller. Commands can be handle in different ways, from create a queue of them to combining or offering support for redo/undo.
In SignalR library I found an implementation of command pattern that caught my attention.

internal interface ICommand
{
    string DisplayName { get; }
    string Help { get; }
    string[] Names { get; }
    void Execute(string[] args);
}
internal abstract class Command : ICommand
{
    public Command(Action<string> info, Action<string> success, Action<string> warning, Action<string> error)
    {
        Info = info;
        Success = success;
        Warning = warning;
        Error = error;
    }

    public abstract string DisplayName { get; }

    public abstract string Help { get; }

    public abstract string[] Names { get; }

    public abstract void Execute(string[] args);

    protected Action<string> Info { get; private set; }

    protected Action<string> Success { get; private set; }

    protected Action<string> Warning { get; private set; }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "May be used in future derivations.")]
    protected Action<string> Error { get; private set; }
}

Why? The way how the handlers for actions like success, warning, info and error are transmitted. When creating the command, you need to specify them through the construct. In this way the developer will be forced to specify them. I think that this a great and simple way to specify them. If a developer don’t want to handle this actions, that he can transmit a null value for them. This solution is better than having one or more events.
Maybe it would be pretty interesting to wrap this 4 parameters in a simple class. In this way you could have all the similar actions under the same object. Beside this we would reduce the numbers of parameters of the Command class with 3.

internal class CommandCallbackActions
{
    public CommandCallbackActions(Action<string> info, Action<string> success, Action<string> warning, Action<string> error)
    {
        Info = info;
        Success = success;
        Warning = warning;
        Error = error;
    }
    
    protected Action<string> Info { get; private set; }

    protected Action<string> Success { get; private set; }

    protected Action<string> Warning { get; private set; }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "May be used in future derivations.")]
    protected Action<string> Error { get; private set; }
}

internal abstract class Command : ICommand
{   
    public Command(CommandCallbackActions callbackActions)
    {
        CallbackActions = callbackActions;
    }

    public abstract string DisplayName { get; }

    public abstract string Help { get; }

    public abstract string[] Names { get; }

    public abstract void Execute(string[] args);

    public CommandCallbackActions CallbackActions { get; set; }
}

Another method that drew my attention was the “Execute” command. The command arguments are send through an array of string. This is a very and simple and robust way to send parameters. If this is enough for your application, than you should not change this to something more complicated. Otherwise you can replace the array of arguments with an interface (“ICommandArgs”). Each custom command can have his implementation of this interface. You should use this only if you really need, otherwise you will only make the project more complicated.