Inyección de dependencia al utilizar el patrón de comando

Question

Estoy usando el patrón de comando por primera vez. Estoy un poco inseguro de cómo debo manejar las dependencias.

En el siguiente código, enviamos un CreateProductCommand que luego se pone en cola para ser ejecutado en otro momento. El comando encapsula toda la información que necesita para ejecutar.

En este caso, es probable que tengamos que acceder a un almacén de datos de algún tipo para crear el producto. Mi pregunta es, ¿cómo inyecto esta dependencia en el comando para que se pueda ejecutar?

public interface ICommand { 
    void Execute(); 
} 

public class CreateProductCommand : ICommand { 
    private string productName; 

    public CreateProductCommand(string productName) { 
     this.ProductName = productName; 
    } 

    public void Execute() { 
     // save product 
    } 
} 

public class Dispatcher { 
    public void Dispatch<TCommand>(TCommand command) where TCommand : ICommand { 
     // save command to queue 
    } 
} 

public class CommandInvoker { 
    public void Run() { 

     // get queue 

     while (true) { 
      var command = queue.Dequeue<ICommand>(); 
      command.Execute(); 
      Thread.Sleep(10000); 
     } 
    } 
} 

public class Client { 
    public void CreateProduct(string productName) { 
     var command = new CreateProductCommand(productName); 
     var dispatcher = new Dispatcher(); 
     dispatcher.Dispatch(command); 
    } 
} 

Muchas gracias
Ben

Answer 1

Después de mirar el código que recomendaría no usar el patrón de comandos, pero en lugar de utilizar los objetos de datos de comandos y un controlador de comandos:

public interface ICommand { } 

public interface ICommandHandler<TCommand> where TCommand : ICommand { 
    void Handle(TCommand command); 
} 

public class CreateProductCommand : ICommand { } 

public class CreateProductCommandHandler : ICommandHandler<CreateProductCommand> { 
    public void Handle(CreateProductCommand command) { 

    } 
} 

Este escenario es más adecuado para los casos en los que CreateProductCommand podría necesitar cruzar los límites de la aplicación. Además, puede tener una instancia de CreateProductCommand resuelta por un contenedor DI con todas las dependencias configuradas. El despachador o "bus de mensajes" invocaría al controlador cuando reciba el comando.

Echa un vistazo a here para obtener información general.