c# - principiantes - que es mvvm en programacion

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 commanding y burbuja arriba del 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 UI. Investigué Prism, pero me pareció demasiado complejo para lo que necesito en este momento. Terminé levantando y manejando eventos, como se describe aquí -> WPF MVVM Corregir modo de disparar evento en vista desde ViewModel

Answer 2

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 como una función normal. Aquí es 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;
    }

Las llamadas Execute2 en lugar de Execute devolverán el valor.

Answer 3

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

Usando el RelayCommand del excelente artículo MVVM de Josh Smith :

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()); puede acceder al nuevo valor de myVM.Thing .

Answer 4

Si Thing2 es otra propiedad en su viewmodel, puede usar INotifyPropertyChanged normal para informar a la UI del cambio.

También puede usar EventAggregator de EventAggregator para un enfoque más desacoplado