Befehl zum Aufrufen der Methode aus ViewModel

Question

OK, ich neige dazu Befehle zu vermeiden, weil sie es immer schaffen, die Hölle von mir zu verwirren, aber ich bin auf ein neues Projekt und versuche, es richtig zu gestalten, ohne Code auf meinem Aussicht. Im Grunde ist alles, was ich gerade versuche, ein Knopf zu drücken, der einen Befehl auslöst, der einige Dinge auf meinem Betrachtungsmodell tut, und irgendwie gibt etwas so einfaches mir immer noch Ärger. Ich denke, ich bin nah dran, komme aber nicht ganz hin. Hier ist, was ich gerade habe.

<Window.Resources> 
    <RoutedUICommand x:Key="GetMusic" /> 
</Window.Resources> 
<Window.DataContext> 
    <core:ViewMain /> 
</Window.DataContext> 
<Window.CommandBindings> 
    <CommandBinding Command="{StaticResource GetMusic}" Executed="GetMusicExecuted"/> 
</Window.CommandBindings> 

Und die Aussicht Modell ist so ziemlich nichts jetzt

public class ViewMain 
{ 
    public MusicCollection Music { get; set; } 

    private void GetMusicExecuted(object sender, ExecutedRoutedEventArgs e) 
    { 
     //Logic 
    } 
} 

Nun, was ich versuche, diesen Befehl zu tun, ist ein Draht von bis ich in meinem Kommando Bindungen einrichten nur meine ausgeführt Methode aufrufen In meinem Sichtmodell versucht es jedoch, diese Methode innerhalb der Sicht selbst zu finden. Gibt es einen Weg, wie ich es stattdessen auf die Methode in meinem Betrachtungsmodell richten kann, oder einen besseren Weg, dies einzurichten, um dasselbe zu erreichen? Ich hoffe, es zunächst einfach zu halten, damit ich nicht zu früh in die Gedanken komme.

Answer 1

Ich neige dazu, meine eigene Befehlsklasse zu verwenden, die ICommand implementiert. Dann binde ich die Button Command-Eigenschaft an die Befehlseigenschaft in meinem Ansichtsmodell. Wenn auf die Schaltfläche geklickt wird, führt sie die Execute-Methode aus, was auch immer an die Command-Eigenschaft gebunden ist.

Dies ist die hässliche 2-Minuten-Version, aber es zeigt, wie Sie eine Command-Klasse erstellen und dann Delegaten zuweisen können, die auf die von Ihnen gewünschte Methode in Ihrem Ansichtsmodell verweisen.

Das Ansichtsmodell:

public class MyViewModel 
{ 
    public MyCommand ActionCommand 
    { 
     get; 
     set; 
    } 

    public MyViewModel() 
    { 
     ActionCommand = new MyCommand(); 
     ActionCommand.CanExecuteFunc = obj => true; 
     ActionCommand.ExecuteFunc = MyActionFunc; 
    } 

    public void MyActionFunc(object parameter) 
    { 
     // Do stuff here 
    } 

} 

public class MyCommand : ICommand 
{ 
    public Predicate<object> CanExecuteFunc 
    { 
     get; 
     set; 
    } 

    public Action<object> ExecuteFunc 
    { 
     get; 
     set; 
    } 

    public bool CanExecute(object parameter) 
    { 
     return CanExecuteFunc(parameter); 
    } 

    public event EventHandler CanExecuteChanged; 

    public void Execute(object parameter) 
    { 
     ExecuteFunc(parameter); 
    } 
} 

Der Blick auf sie binden würde thusly (vorausgesetzt, dass Datacontext auf eine Instanz der View-Modell eingestellt ist):

<Window x:Class="exp.MainWindow" 
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
     Title="MainWindow" Height="350" Width="525"> 
    <Grid> 
     <Button Command="{Binding Path=ActionCommand}">Action</Button> 
    </Grid> 
</Window>