Ist Josh Smiths Implementierung des RelayCommand fehlerhaft?

Betrachten der Referenz Josh Smith' Artikel WPF-Anwendungen Mit Dem Model-View-ViewModel Design Patterninsbesondere die Beispiel-Implementierung einer RelayCommand (Abbildung 3). (Keine Notwendigkeit, Sie zu Lesen, durch die ganzen Artikel für diese Frage.)

Im Allgemeinen, ich denke, die Umsetzung ist hervorragend, aber ich habe eine Frage über die delegation von CanExecuteChanged Abonnements für die CommandManager's RequerySuggested Veranstaltung. Die Dokumentation für RequerySuggested Staaten:

Seit diesem Ereignis ist statisch, es wird
nur halt an der hf als schwach
Referenz. Objekte, die zu hören für
diese Veranstaltung soll weiterhin ein starker
Verweis auf Ihre event-handler
vermeiden, es wird Müll gesammelt. Diese
kann erreicht werden durch eine
privaten Bereich und die Zuordnung der
handler als Wert vor oder nach
Befestigung an dieses Ereignis.

Doch die Beispiel-Implementierung von RelayCommand nicht halten Sie solche an den registrierten handler:

public event EventHandler CanExecuteChanged
{
    add { CommandManager.RequerySuggested += value; }
    remove { CommandManager.RequerySuggested -= value; }
}
  1. Hat dieses Leck der schwache Verweis bis zur RelayCommand's client, erfordern, dass der Benutzer des RelayCommand verstehen, die Umsetzung der CanExecuteChanged und halten ein Leben auf sich selbst verweisen?

  2. Wenn dem so ist, macht es Sinn, zum Beispiel, ändern Sie die Implementierung der RelayCommand etwas wie den folgenden zur Begrenzung der potenziellen vorzeitigen GC der CanExecuteChanged Abonnenten:

    //This event never actually fires.  It's purely lifetime mgm't.
private event EventHandler canExecChangedRef;
public event EventHandler CanExecuteChanged
{
    add 
    { 
        CommandManager.RequerySuggested += value;
        this.canExecChangedRef += value;
    }
    remove 
    {
        this.canExecChangedRef -= value;
        CommandManager.RequerySuggested -= value; 
    }
}

InformationsquelleAutor der Frage Greg D | 2010-02-17

  1. 7

    Auch ich glaube, dass diese Implementierung ist fehlerhaftweil es definitiv verliert den schwachen Verweis auf die Ereignisprozedur. Dies ist etwas, was eigentlich sehr schlecht ist.

    Ich bin mit dem MVVM Light toolkit und die RelayCommand darin umgesetzt und implementiert ist es nur wie in dem Artikel.

    Der folgende code wird nie aufrufen OnCanExecuteEditChanged:

    private static void OnCommandEditChanged(DependencyObject d, 
                                         DependencyPropertyChangedEventArgs e)
{
    var @this = d as MyViewBase;
    if (@this == null)
    {
        return;
    }

    var oldCommand = e.OldValue as ICommand;
    if (oldCommand != null)
    {
        oldCommand.CanExecuteChanged -= @this.OnCanExecuteEditChanged;
    }
    var newCommand = e.NewValue as ICommand;
    if (newCommand != null)
    {
        newCommand.CanExecuteChanged += @this.OnCanExecuteEditChanged;
    }
}

    Jedoch, wenn ich eine änderung wie diese, wird es funktionieren:

    private static EventHandler _eventHandler;

private static void OnCommandEditChanged(DependencyObject d,
                                         DependencyPropertyChangedEventArgs e)
{
    var @this = d as MyViewBase;
    if (@this == null)
    {
        return;
    }
    if (_eventHandler == null)
        _eventHandler = new EventHandler(@this.OnCanExecuteEditChanged);

    var oldCommand = e.OldValue as ICommand;
    if (oldCommand != null)
    {
        oldCommand.CanExecuteChanged -= _eventHandler;
    }
    var newCommand = e.NewValue as ICommand;
    if (newCommand != null)
    {
        newCommand.CanExecuteChanged += _eventHandler;
    }
}

    Der einzige Unterschied? Nur wie in der Dokumentation von CommandManager.RequerySuggested ich bin das speichern der event-handler in einem Feld.

    InformationsquelleAutor der Antwort Daniel Hilgarth

  2. 41

    Habe ich die Antwort gefunden, in Josh ' s Kommentar auf seine "Verständnis Weitergeleitet Befehle" Artikel:

    [...] müssen Sie das WeakEvent-Muster in Ihrem CanExecuteChanged
    event. Dies ist, da visual-Elemente Haken, der Fall, und da
    das command-Objekt kann nie Müll gesammelt, bis die app
    heruntergefahren, es gibt eine sehr Reale Potenzial für ein Speicher-Leck. [...]

    Das argument scheint zu sein, dass CanExecuteChanged implementors müssen nur halt schwach auf der registrierten Handler, da WPF Visuals sind zu dumm, um zu trennen Sie sich. Dies wird am einfachsten realisiert durch das delegieren an den CommandManagerwer tut dies bereits. Vermutlich aus dem gleichen Grund.

    InformationsquelleAutor der Antwort David Schmitt

  3. 7

    Gut, nach Reflektor implementiert die gleiche Art und Weise, in der RoutedCommand Klasse, also ich denke, es muss OK sein... es sei denn, jemand im WPF-team einen Fehler gemacht 😉

    InformationsquelleAutor der Antwort Thomas Levesque

  4. 5

    Ich glaube, es ist fehlerhaft.

    Durch Umleitung der Ereignisse auf der BefehlsManager, bekommen Sie das folgende Verhalten

    Dadurch wird sichergestellt, dass die WPF-Kommandierender
    Infrastruktur bittet alle RelayCommand
    wenn die Objekte, die Sie ausführen können, Wann immer
    es fordert die built-in-Befehle.

    Jedoch, was passiert, wenn Sie wünschen, informieren Sie alle Steuerelemente an einem einzigen Befehl zu re-evaluieren, die CanExecute-status? In seiner Umsetzung, Sie gehen müssen, um den BefehlsManager, Bedeutung

    Jeden einzelnen Befehl verbindlich, Ihre Anwendung wird neu bewertet

    Umfasst alle diejenigen, die don ' T Angelegenheit zu einem Hügel von Bohnen, diejenigen, bei denen die Bewertung der CanExecute-Nebenwirkungen (wie z.B. Datenbank-Zugriff oder lang laufende Aufgaben), diejenigen, die darauf warten, abgeholt zu werden... es ist wie mit einem Vorschlaghammer auf Laufwerk a friggen Nagel.

    Sie haben, um ernsthaft über die Auswirkungen dieses Vorgangs.

    InformationsquelleAutor der Antwort Will

  5. 0

    Ich möglicherweise fehlt den Punkt hier aber nicht die folgenden bilden den starken Bezug zu den event-handler in den contructor?

        _canExecute = canExecute;

    InformationsquelleAutor der Antwort Lazarus

Schreibe einen Kommentar