How to share the same context between commands in Command-Pattern with C#?

Question

I've implemented the command pattern (in a multi-support way) in my application.

Structure:

class MultiCommand : BaseCommand

abstract class BaseCommand : ICommand

Process Flow:

   var commandsGroup = new MultiCommand(new List<ICommand>()
            {
                new Command1(),
                new Command2(),
                new Command3(),
            });

   commandsGroup.Execute()

Now, suppose that in Command1 a somethingID is changed and I'll use this new value in Command2... And also, that there are plenty of other properties and objects that are being affected during the whole execution process.

Also, there are some interface implementations that should be available at any command just using the context object like:

Context.ServerController.something();

The instantiation of the IServerController will take place just before the multiCommandGroup initialization.

How can I have a shared context like this for all Commands of the group?

Example of the Context class:

public class CommandContext
{
    public IServerController ServerController;
    public RequiredData Data { get; set; }

    public CommandContext(){}
}

IMPORTANT A minimal implementation Code is here

Answer 1

1) If you want to keep this interface, then you have to pass this context as constructor parameter:

new MultiCommand(new List<ICommand>()
            {
                new Command1(context),
                new Command2(context),
                new Command3(context),
            })

2) As another option you can accept list of delegates instead of list of commands. MultiCommand will be look like this:

class MultiCommand : ICommand
{
    public MultiCommand(List<Func<Context, Command>> commands, Context context)

}

That is almost the same except MultiCommand is responsible for all the commands share the same context.

3) Looks like commands in MultiCommand depends on result of previous command. In this case Command pattern is not probably the best. Maybe you should try to implement Middleware chain here?

interface IMiddleware<TContext>
{
   void Run(TContext context);
}

class Chain<TContext>
{
    private List<IMiddleware<TContext>> handlers;

    void Register(IMiddleware<TContext> m);

    public void Run(TContext context)
    {
        handlers.ForEach(h => h.Run(context));
    }
}

Answer 2

I would suggest to make somethings generic. Here is a super simple example.

class MultiCommand<TContext>  
{
    List<Command<TContext>> Commands;
    TContext Context;
}