Chain of commands

Question

I need to execute several commands in a specific order but before I excute the main command, another command needs to be executed first and in some situations there are more commands that also need to be executed last.

To achieve this I build an extended chain of resposibility. It does not only have a post-command but also a pre-command. The main command in the middle is the one that a user sees in a menu.

internal abstract class Command
{
    public Command Pre { get; set; }

    public Command Post { get; set; }

    public int Execute()
    {
        var executedCommandCount = 0;

        if (Pre != null)
        {
            var preResult = Pre.Execute();
            if (preResult == 0) { return executedCommandCount; }
            executedCommandCount += preResult;
        }

        if (!ExecuteCore())
        {
            return executedCommandCount;
        }

        executedCommandCount++;

        if (Post != null)
        {
            var postResult = Post.Execute();
            if (postResult == 0) { return executedCommandCount; }
            executedCommandCount += postResult;
        }

        return executedCommandCount;
    }

    protected abstract bool ExecuteCore();
}

Test commands:

class FirstCommand : Command
{
    protected override bool ExecuteCore()
    {
        return true;
    }
}

class MainCommand : Command
{
    protected override bool ExecuteCore()
    {
        return true;
    }
}

class LastCommand : Command
{
    protected override bool ExecuteCore()
    {
        return true;
    }
}

Example:

var mainCommand = new MainCommand
{
    Pre = new FirstCommand(),
    Post = new LastCommand()
};

var executedCommandCount = mainCommand.Execute(); // 3

Mathieu Guindon · Accepted Answer · 2016-11-24 17:18:33Z

Why not implement WPF's ICommand? That way you could use them in command bindings, and if you're not using WPF, you could still attach them to click handlers and use their CanExecute method to determine whether to enable or disable a menu item.

It's not immediately obvious why a command's Execute method would return anything. Having a parameterized command (like ICommand has) could be used to eliminate the need for that bool return value. It's not clear what the int value might be used for either (other than debugging?).

The setters for Pre and Post should be protected IMO; they have no business on the type's public interface.

The null checks indicate that not all implementations actually need a Pre or a Post command: to me this is starting to smell a bit.

Seems a more robust and flexible design would be a simple ICommand with decorators - here over a classic DelegateCommand base class implementing ICommand:

public class PreExecuteCommandDecorator : DelegateCommand
{
    private readonly DelegateCommand _command;
    private readonly Action<object> _action;

    public PreExecuteCommandDecorator(DelegateCommand command, Action<object> action)
    {
        _command = command;
        _action = action;
    }

    public override bool CanExecute(object parameter)
    {
        return _command.CanExecute(parameter);
    }

    public override void ExecuteCore(object parameter)
    {
        _action.Invoke(parameter);
        _command.Execute(parameter);
    }
}

Similarly:

public class PostExecuteCommandDecorator : DelegateCommand
{
    private readonly DelegateCommand _command;
    private readonly Action<object> _action;

    public PostExecuteCommandDecorator(DelegateCommand command, Action<object> action)
    {
        _command = command;
        _action = action;
    }

    public override bool CanExecute(object parameter)
    {
        return _command.CanExecute(parameter);
    }

    public override void ExecuteCore(object parameter)
    {
        _command.Execute(parameter);
        _action.Invoke(parameter);
    }
}

That way you could build your "chain of command" in a much cleaner way IMO - especially if you're building an actual "chain" with pre-commands that have their own pre and post commands that have their own pre and post commands that have their own pre... well you get the idea.

I like the decorator idea. Currently I use this in a console application but later I'm going to upgrade this to WPF so using the right objects from the beginning would save actually a lot of work. (it's a nuget automation tool that for example needs to update nuspec files before executing pack etc.) — t3chb0t
– t3chb0t, Commented Nov 24, 2016 at 17:25
This has only one flaw: if one command fails the next one must not be executed... I'll try to come up with something. — t3chb0t
– t3chb0t, Commented Nov 24, 2016 at 17:29
Sounds like a plan - depending on what the pre/post actions actually are (cross-cutting concerns?), and whether you're using DI (and an IoC framework that supports it), consider implementing interceptors - they're pretty much like decorators, with pre/post execute hooks. — Mathieu Guindon
– Mathieu Guindon, Commented Nov 24, 2016 at 17:47

2 revs · Accepted Answer · 2016-11-24 18:29:18Z

This is my final implementation where I use the WPF's ICommand, a decorator for composition and two factory extensions to chain the commands.

internal class LinkedCommand : ICommand 
{
    private readonly ICommand _pre;
    private readonly ICommand _post;

    public LinkedCommand(ICommand pre, ICommand post)
    {
        _pre = pre;
        _post = post;
    }   

    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object arg)
    {
        return _pre.CanExecute(arg) && _post.CanExecute(arg);
    }

    public void Execute(object arg)
    {
        _pre.Execute(arg);
        _post.Execute(arg);
    }
}

Two factory extensions:

public static class CommandComposition
{ 
    public static ICommand Pre(this ICommand current, ICommand pre)
    {
        return new LinkedCommand(pre, current);
    }

    public static ICommand Post(this ICommand current, ICommand post)
    {
        return new LinkedCommand(current, post);
    }
}

Example commands:

class FirstCommand : ICommand
{
    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object arg) => true;

    public void Execute(object arg)
    {
        Console.WriteLine("First");
    }
}

class MainCommand : ICommand
{
    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object arg) => true;

    public void Execute(object arg)
    {
        Console.WriteLine("Main");
    }
}

class LastCommand : ICommand
{
    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object arg) => true;

    public void Execute(object arg)
    {
        Console.WriteLine("Last");
    }
}

Now the usage is nice and clean:

var mainCommand = new MainCommand().Pre(new FirstCommand()).Post(new LastCommand());
mainCommand.Execute(null);

First
Main
Last

Stack Exchange Network

Chain of commands

2 Answers 2

You must log in to answer this question.

Hot Network Questions

Chain of commands

2 Answers 2

You must log in to answer this question.

Related

Hot Network Questions