Comando en MVVM (WPF): cómo devolver un valor?

Question

He estado usando el patrón MVVM desde hace un tiempo, pero todavía tengo problemas en situaciones de la vida real. Aquí hay otro: Uso comando y burbuja hasta el evento para ser manejado en el ViewModel. Hasta aquí todo bien. Pero el proyecto para el que estoy usando MVVM es en realidad una biblioteca de clases. Una vez que ejecuto el código de comando, necesito poder enviar un objeto de vuelta a la aplicación de llamada. ¿Cuáles son las formas sugeridas de hacerlo?

Específicamente: En mi aplicación de llamada tengo una página XAML ligada directamente al ViewModel de la biblioteca, que contiene un objeto "Thing1". Cuando se hace clic en un botón, se llama a un método en ViewModel (llámelo "CopyThing1()"). Copia "Thing1" para crear "Thing2". Entonces necesito enviar "Thing2" a la aplicación de llamada.

Gracias !!!

Answer 1

Aunque la información sobre Commanding fue clara y correcta, no se pudo aplicar en mi caso porque la respuesta requerida era que una aplicación de llamada NO utilizara MVVM y que no fuera solo una respuesta de IU. Investigué Prism, pero me pareció demasiado complejo para lo que necesito en este momento. Terminé la crianza y manejo de eventos, tal como se describe aquí -> WPF MVVM Correct Way to Fire Event on View From ViewModel

Answer 2

Si Thing2 es otra propiedad en su viewmodel, puede utilizar INotifyPropertyChanged normal para informar a la interfaz de usuario del cambio.

También es posible usar Prism 's EventAggregator de un enfoque más disociadas

Answer 3

Los comandos no devuelven valores, cambian el estado de su solicitud. En el caso de ICommands adjuntos a ViewModels es bastante simple, porque puedes hacer esto simplemente mutando el ViewModel cuando se ejecuta el comando.

Utilizando el RelayCommand de Josh Smith's excellent MVVM article:

public class MyViewModel : INotifyPropertyChanged 
{ 
    private readonly ICommand mutateCommand; 
    private Thing thing; 

    public MyViewModel() 
    { 
     this.mutateCommand = new RelayCommand(this.Mutate); 
    } 

    public ICommand MutateCommand 
    { 
     get { return this.mutateCommand; } 
    } 

    public Thing Thing 
    { 
     get { return this.thing; } 
     set 
     { 
      this.thing = value; 
      // raise PropertyChanged event here... 
     } 
    } 

    private void Mutate(object parameter) 
    { 
     this.Thing = new Thing(); 
    } 
} 

Después de llamar myVM.MutateCommand.Execute(new object()); se puede acceder al nuevo valor de myVM.Thing.

Answer 4

El enfoque ideal es definir una nueva clase heredada de ICommand de la siguiente manera:

public abstract class Command2<T1, T2> : ICommand { 
    public abstract T2 Execute2(T1 parameter); 
} 

public class DelegateCommand2<T1, T2> : Command2<T1, T2> { 
    public DelegateCommand2(Func<T1, T2> execute, Predicate<T1> canExecute) { 
     _execute = execute; 
     _canExecute = canExecute; 
    } 

    public override T2 Execute2(T1 parameter) { 
     if (CanExecute(parameter) == false) 
      return default(T2); 
     else 
      return _execute((T1)parameter); 
    } 
} 

Tenga en cuenta que Execute2 devuelve el valor igual una función normal. He aquí cómo usarlo.

private readonly ICommand _commandExample = new DelegateCommand2<int, Point3D>(
     commandExample_Executed, 
     commandExample_CanExecute 
    ); 

    public Command2<int, Point_3D> CommandExample { 
     get { 
      return (Command2<int, Point_3D>) _commandExample; 
     } 
    } 

    private static Point3D commandExample_Executed(int index) { 
     return Fun1(index); //Fun1 returns a Point_3D 
    } 

    private static bool commandExample_CanExecute(int index) { 
     return true; 
    } 

Llamadas Execute2 en lugar de Execute devolverá el valor.