Patrón de comando: cómo pasar parámetros a un comando?

Question

Mi pregunta está relacionada con el patrón de comandos, donde tenemos la siguiente abstracción (código C#):

public interface ICommand 
{ 
    void Execute(); 
} 

Tomemos un simple comando de hormigón, que tiene como objetivo eliminar una entidad de nuestra aplicación. Una instancia de Person, por ejemplo.

Tendré un DeletePersonCommand, que implementa ICommand. Este comando necesita el Person para eliminar como parámetro, para eliminarlo cuando se llama al método Execute.

¿Cuál es la mejor manera de gestionar comandos parametrizados? ¿Cómo pasar parámetros a los comandos antes de ejecutarlos?

Answer 1

Tendrá que asociar los parámetros con el objeto de comando, ya sea por el constructor o inyección setter (o equivalente). Tal vez algo como esto:

public class DeletePersonCommand: ICommand 
{ 
    private Person personToDelete; 
    public DeletePersonCommand(Person personToDelete) 
    { 
     this.personToDelete = personToDelete; 
    } 

    public void Execute() 
    { 
     doSomethingWith(personToDelete); 
    } 
} 

Answer 2

En el constructor y almacenado como campos.

También deseará eventualmente hacer sus ICommands serializables para la pila de deshacer o la persistencia del archivo.

Answer 3

DeletePersonCommand puede tener un parámetro en su constructor o métodos. DeletePersonCommand tendrá Execute() y en el atributo execute can check que Getter/Setter pasará previamente a la llamada de Execute().

Answer 4

Agregaría los argumentos necesarios al constructor de DeletePersonCommand. Luego, cuando se llama al Execute(), se usan los parámetros pasados ​​al objeto en el momento de la construcción.

Answer 5

Haga que "Persona" implemente algún tipo de interfaz IDeletable, luego haga que el comando tome la clase base o la interfaz que usen sus entidades. De esta manera, se puede hacer una DeleteCommand, que trata de echar la entidad a un IDeletable, y si funciona, llame .Delete

public class DeleteCommand : ICommand 
{ 
    public void Execute(Entity entity) 
    { 
     IDeletable del = entity as IDeletable; 
     if (del != null) del.Delete(); 
    } 
} 

Answer 6

hay algunas opciones:

Se podía pasar parámetros de propiedades o el constructor.

Otra opción podría ser:

interface ICommand<T> 
{ 
    void Execute(T args); 
} 

y encapsular todos los parámetros de comando en un objeto de valor.

Answer 7

Pasar la persona cuando se crea el objeto de comando:

ICommand command = new DeletePersonCommand(person); 

de modo que cuando se ejecuta el comando, que ya sabe todo lo que necesita saber.

class DeletePersonCommand : ICommand 
{ 
    private Person person; 
    public DeletePersonCommand(Person person) 
    { 
     this.person = person; 
    } 

    public void Execute() 
    { 
     RealDelete(person); 
    } 
} 

Answer 8

En este caso, lo que hemos hecho con nuestros objetos de comando es la creación de un objeto de contexto que es esencialmente un mapa. El mapa contiene pares de valores de nombre donde las claves son constantes y los valores son parámetros que utilizan las implementaciones de Comando. Especialmente útil si tiene una Cadena de comandos donde los comandos posteriores dependen de los cambios de contexto de los comandos anteriores.

Así el método real se convierte en

void execute(Context ctx); 

Answer 9

Basado en el patrón en C#/WPF la Interfaz ICommand (System.Windows.Input.ICommand) se define para tomar un objeto como un parámetro en la ejecución, como se así como el método CanExecute.

interface ICommand 
      { 
       bool CanExecute(object parameter); 
       void Execute(object parameter); 
      } 

Esto le permite definir su comando como un campo estático del público, que es una instancia de su objeto de comando personalizado que implementa ICommand.

public static ICommand DeleteCommand = new DeleteCommandInstance(); 

De esta forma, el objeto relevante, en su caso una persona, se transfiere cuando se ejecuta execute. El método Execute puede lanzar el objeto y llamar al método Delete().

public void Execute(object parameter) 
      { 
       person target = (person)parameter; 
       target.Delete(); 
      } 

Answer 10

Debe crear un objeto CommandArgs para que contenga los parámetros que desea utilizar. Inyecte el objeto CommandArgs utilizando el constructor del objeto Command.

Answer 11

pasar los datos a través de un constructor o trabajos setter, pero requiere el creador del comando para conocer los datos de las necesidades de mando ...

La idea "contexto" es realmente bueno, y yo estaba trabajando en (un marco interno) que lo apalancó hace un tiempo.

Si configura su controlador (componentes de IU que interactúan con el usuario, CLI interpretando comandos de usuario, interpretando parámetros entrantes y datos de sesión, etc.) para proporcionar acceso con nombre a los datos disponibles, los comandos pueden solicitar directamente los datos ellos quieren.

Me gusta mucho la separación que permite una configuración como esta. Piense en capas de la siguiente manera:

User Interface (GUI controls, CLI, etc) 
    | 
[syncs with/gets data] 
    V 
Controller/Presentation Model 
    |     ^
[executes]    | 
    V     | 
Commands --------> [gets data by name] 
    | 
[updates] 
    V 
Domain Model 

Si lo hace este "derecho", los mismos comandos y modelo de presentación se pueden utilizar con cualquier tipo de interfaz de usuario.

Llevando esto un paso más allá, el "controlador" de arriba es bastante genérico. Los controles de la interfaz de usuario solo necesitan conocer el nombre del comando que invocarán; ellos (o el controlador) no necesitan tener ningún conocimiento de cómo crear ese comando o qué datos necesita ese comando. Esa es la verdadera ventaja aquí.

Por ejemplo, puede mantener el nombre del comando para ejecutar en un Mapa. Cada vez que el componente se "activa" (generalmente una acción realizada), el controlador busca el nombre del comando, lo instancia, llama a ejecutar y lo empuja a la pila de deshacer (si usa uno).

Answer 12

Mi aplicación sería esto (utilizando el ICommand propuesto por Juanma):

public class DeletePersonCommand: ICommand<Person> 
{ 
    public DeletePersonCommand(IPersonService personService) 
    { 
     this.personService = personService; 
    } 

    public void Execute(Person person) 
    { 
     this.personService.DeletePerson(person); 
    } 
} 

IPersonService podría ser un IPersonRepository, depende de lo que "capa" de su comando está.