Update UI von der ViewModel-Klasse (MVVM-pattern) in WPF

Ich bin mit dem MVVM-Muster in meine erste WPF-Anwendung und haben ein problem mit etwas, das Recht einfach ist, nehme ich an.

Wenn der Nutzer auf die Schaltfläche "speichern" in meiner Sicht, ein Befehl wird ausgeführt, ruft die private void Speichern() in meinem ViewModel.

Das problem ist, dass der code in "Save()" dauert einige Zeit zum ausführen, also würde ich gerne zum ausblenden der Schaltfläche "Speichern" in der UI-Ansicht vor der Ausführung der großen Batzen code.

Das problem ist, dass die Ansicht nicht aktualisieren, bis der gesamte code wird ausgeführt, in das viewmodel.
Wie kann ich erzwingen Sie die Ansicht neu zu zeichnen und zu verarbeiten, das PropertyChanged-Ereignisse vor der Ausführung der Save () - code?

Zusätzlich würde ich gerne eine reuseable, so dass ich kann leicht tun die gleiche Sache in anderen Seiten als gut.. Jemand anderes so etwas schon? Ein "Loading..." - Meldung?

InformationsquelleAutor Thomas Stock | 2009-11-18
  1. 11

    Wenn es dauert eine lange Zeit, ziehen Sie die Verwendung einer separaten thread, zum Beispiel mit einer BackgroundWorker, sodass der UI-thread kann bleiben ansprechbar (D. H. die Aktualisierung der Benutzeroberfläche), während der Vorgang durchgeführt wird.

    In Ihrem Save - Methode, Sie würde

    • ändern Sie die Benutzeroberfläche (D. H. ändern Sie einige INotifyPropertyChanged oder DependencyProperty IsBusySaving boolean, die gebunden ist, um Ihre UI blendet die Schaltfläche Speichern und vielleicht zeigt einige Fortschritte bar mit IsIndeterminate = True) und
    • starten BackgroundWorker.

    In der DoWork event-handler für das BackgroundWorker, tun Sie das langwierige sparsamen Betrieb.

    In der RunWorkerCompleted Ereignisprozedur, die ausgeführt wird, in dem UI-Faden, legen Sie IsBusySaving auf false und vielleicht ändern andere Sachen in der Benutzeroberfläche, um zu zeigen, dass Sie fertig sind.

    Code-Beispiel (ungetestet):

    BackgroundWorker bwSave;
DependencyProperty IsBusySavingProperty = ...;

private MyViewModel() {
    bwSave = new BackgroundWorker();

    bwSave.DoWork += (sender, args) => {
        //do your lengthy save stuff here -- this happens in a separate thread
    }

    bwSave.RunWorkerCompleted += (sender, args) => {
        IsBusySaving = false;
        if (args.Error != null)  //if an exception occurred during DoWork,
            MessageBox.Show(args.Error.ToString());  //do your error handling here
    }
}

private void Save() {
    if (IsBusySaving) {
        throw new Exception("Save in progress -- this should be prevented by the UI");
    }
    IsBusySaving = true;
    bwSave.RunWorkerAsync();
}
    • danke, ich werde es einmal versuchen.
    • sorry ich bin ein total dumbo, wenn es um die threading. Innerhalb der Save-code, den ich (manchmal) versuchen, navigieren Sie zu einer anderen Seite. Aber da bin ich in einem anderen thread, das gibt einen Laufzeitfehler. Ich glaube, ich habe zu tun, einen Rückruf an den original-thread und navigieren Sie von dort aus auf die andere Seite. Aber ich werde versuchen, es selbst, ich bin sicher, es ist nicht schwer, kommuniziert mit den original-thread.
    • "The calling thread cannot access this object, da in einem anderen thread gehört." ist die Meldung die ich bekomme. Wenn Sie wissen auswendig, was ich brauche, lass es mich wissen 🙂
    • RunWorkerCompleted, das ist das, was ich brauchte. Vielen Dank. Auch genial zu sehen, ich kann erklären die Event-Handler so, wusste nicht, dass!
    • Ja, RunWorkerCompleted ist genau der richtige Ort, da läuft es in den UI-thread. Wenn Sie brauchen, um zu ändern, UI-Sachen während die Speichern-operation, können Sie entweder Application.Current.Dispatcher.Invoke oder die ReportProgress Methode/ProgressChanged event-Kombination der BackgroundWorker.
    • Du bist mein held.
    • Sie immer noch müssen, deaktivieren die Schaltfläche speichern, wenn IsBusySaving == true, oder geben Sie ein Schloss in der DoWork-um NICHT selbst in eine race-Bedingung.
    • ist es ausreichend, um die CanExecute auf "IsBusySaving == false" meine SaveCommand?
    • Ich Schätze so. Wenn Sie wollen etwas besonderes, Sie können auch hinzufügen, einige "Speicherung läuft..." - text auf der Benutzeroberfläche, deren Sichtbarkeit gebunden ist IsBusySaving über eine BooleanToVisibilityConverter.
    • ja, ich habe bereits verwenden, zu verbergen die-Taste. danke.

    InformationsquelleAutor Heinzi
  2. 3

    Bist du mit MVVM-Muster, so dass Ihre Schaltfläche Speichern den Befehl auf eine Instanz der RoutedCommand-Objekt, das Hinzugefügt wird, um das Fenster CommandBindings-Sammlung aufgenommen werden, die entweder deklarativ oder Imperativ.

    Unter der Annahme, dass Sie es tun deklarativ. So etwas wie

    <Window.CommandBindings>
    <CommandBinding
        Command="{x:Static namespace:ClassName.StaticRoutedCommandObj}"
        CanExecute="Save_CanExecute"
        Executed="Save"
    />
</Window.CommandBindings>

    Für den der handler Ausgeführt geleitet Ereignis, das der Save () - Methode, bei der Einreise, legen Sie eine variable auf false, bei der Rückkehr legen Sie es wieder auf true. So etwas wie.

    void Save(object sender, ExecutedRoutedEventArgs e)
{
    _canExecute = false;
    //do work
    _canExecute = true; 
}

    Für das CanExecute-handler des routed-event, die Save_CanExecute () - Methode, verwenden Sie die variable als eine der Bedingung.

    void ShowSelectedXray_CanExecute(object sender, CanExecuteRoutedEventArgs e)
{
    e.CanExecute = _canExecute && _others;
}

    Ich hoffe, ich bin klar. 🙂

    InformationsquelleAutor tranmq
  3. 0

    Konnte man immer etwas tun, wie dieses:

    public class SaveDemo : INotifyPropertyChanged
{
  public event PropertyChangedEventHandler PropertyChanged;
  private bool _canSave;

  public bool CanSave
  {
    get { return _canSave; }
    set
    {
      if (_canSave != value)
      {
        _canSave = value;
        OnChange("CanSave");
      }
    }
  }

  public void Save()
  {
    _canSave = false;

    //Do the lengthy operation
    _canSave = true;
  }

  private void OnChange(string p)
  {
    PropertyChangedEventHandler handler = PropertyChanged;
    if (handler != null)
    {
      handler(this, new PropertyChangedEventArgs(p));
    }
  }
}

    Dann konnte Sie binden die IsEnabled-Eigenschaft der Schaltfläche auf den CanSave-Eigenschaft, und es wird automatisch aktiviert/deaktiviert werden. Eine alternative Methode, und eine, die ich gehen würde, mit wäre das mit dem Befehl CanExecute zu Sortieren, aber die Idee ist ähnlich genug für Sie, mit zu arbeiten.

    • (1) Wenn Sie _canSave statt CanSave, OnChange wird nicht ausgelöst. (2) ich glaube nicht, dass es funktionieren wird, da Sparen Sie läuft im UI-thread, also der WPF-Benutzeroberfläche nicht aktualisiert werden, bis Speichern beendet hat.
    • ja, in der Tat, ich appriciate die Antwort, aber ich glaube nicht, dass es behebt mein problem. Heinzi ' s Vorschlag es behoben.
    • gute Stelle auf der CanSave, und ja, es wird funktionieren, weil die Benachrichtigung ändern wird ausgelöst beim start des speichern-operation - also die UI-updates an dieser Stelle.
    InformationsquelleAutor Pete OHanlon
  5. 0

    Erreichen Sie dies durch den folgenden code.

    Thread workerThread = null;
void Save(object sender, ExecutedRoutedEventArgs e)
{
workerThread = new Thread(new ThreadStart(doWork));
SaveButton.isEnable = false;
workerThread.start();
}

    alles tun, Ihre langwieriger Prozess in dowork() Methode

    in einige andere Methode...

    workerThread.join();
SaveButtton.isEnable = true;

    Dadurch wird zum ausführen speichern langwieriger Prozess ist, in einem anderen thread und wird nicht blockieren der Benutzeroberfläche, wenn Sie zeigen möchten, eine animation, während der Benutzer auf die Schaltfläche speichern klicken, dann zeigen einige Fortschrittsanzeige wie iPhone usw... geben Sie mir feedback, ich werde versuchen, Ihnen zu helfen sogar noch mehr.

    InformationsquelleAutor AZ_
  6. 0

    Späte Antwort, aber ich dachte, es würde gut sein, um input-als auch ein bisschen.

    Statt der Erstellung Ihrer eigenen neuen thread, wäre es wahrscheinlich besser, es zu verlassen bis zu den threadpool ausgeführt speichern. Es nicht zwingen, es zu laufen, sofort wie die Erstellung Ihrer eigenen thread, aber es erlaubt Ihnen, zu speichern, threading-Ressourcen.

    Den Weg das zu tun ist:

    ThreadPool.QueueUserWorkItem(Save);

    Das problem mit diesem Ansatz ist auch, dass Sie verpflichtet sind, Ihre "Save ()" - Methode nehmen Sie in einem Objekt, das Sie handeln wie ein Staat. Ich hatte ein ähnliches problem, zu verkaufen und beschlossen, diesen Weg zu gehen, denn der Ort, an dem ich arbeite, ist sehr Ressourcen-Bedürftig.

    • danke für deine Antwort. Ich verwendet die akzeptierte Antwort auf meine Bewerbung und es funktioniert gut. Ich weiß nicht, wie die Auslastung ist im Vergleich zu deiner Lösung, aber der backgroundworker ist sehr bequem, mit zu arbeiten.
    • Keith: In .Net 3.5 und höher, betrachten die lambda-Ausdrücke zum trimmen des state-Objekts, wenn Sie es nicht brauchen. ThreadPool.QueueUserWorkItem(state => Speichern()); Vielleicht ein wenig mehr Aufwand hier aber der code ist oft einfacher, mit weniger delegieren, zu beschwichtigen Methoden im Umlauf. Sie können auch eine lambda-Umwandlung die state-Objekt zu dem, was Sie brauchen, und ziehen Sie bestimmte Eigenschaften zu. ThreadPool.QueueUserWorkItem(state => Speichern(Staat als SaveArgs).Länge, Zustand wie SaveArgs).TimeStamp);
    InformationsquelleAutor Keith B
Schreibe einen Kommentar