Entsorgen von WPF-Benutzersteuerelementen

Ich habe ein benutzerdefiniertes WPF-Benutzersteuerelement erstellt, das von Dritten verwendet werden soll. Mein Steuerelement hat ein privates Mitglied, das verfügbar ist, und ich möchte sicherstellen, dass seine Entsorgungsmethode immer aufgerufen wird, sobald das enthaltende Fenster / die enthaltende Anwendung geschlossen wird. UserControl ist jedoch nicht verfügbar. Ich habe versucht, die IDisposable-Schnittstelle zu implementieren und das Unloaded-Ereignis zu abonnieren, aber beide werden beim Schließen der Host-Anwendung nicht aufgerufen. Wenn möglich, möchte ich mich nicht darauf verlassen, dass Verbraucher meiner Kontrolle daran denken, eine bestimmte Dispose-Methode aufzurufen.

 public partial class MyWpfControl : UserControl
 {
     SomeDisposableObject x;

     // where does this code go?
     void Somewhere() 
     {
         if (x != null)
         {
             x.Dispose();
             x = null;
         }

     }
 }

Die einzige Lösung, die ich bisher gefunden habe, besteht darin, das ShutdownStarted-Ereignis des Dispatchers zu abonnieren. Ist das ein vernünftiger Ansatz?

this.Dispatcher.ShutdownStarted += Dispatcher_ShutdownStarted;

Interessanter Blogbeitrag hier:

http://geekswithblogs.net/cskardon/archive/2008/06/23/dispose-of-a-wpf-usercontrol-ish.aspx

Es wird erwähnt, dass Sie Dispatcher.ShutdownStarted abonniert haben , um Ihre Ressourcen zu entsorgen.

Dispatcher.ShutdownStartedEreignis wird erst am Ende der Anwendung ausgelöst. Es lohnt sich, die Entsorgungslogik nur dann aufzurufen, wenn die Steuerung außer Betrieb ist. Insbesondere werden Ressourcen frei, wenn die Steuerung während der Anwendungslaufzeit häufig verwendet wird. Daher ist die Lösung von ioWint vorzuziehen. Hier ist der Code:

public MyWpfControl()
{
     InitializeComponent();
     Loaded += (s, e) => { // only at this point the control is ready
         Window.GetWindow(this) // get the parent window
               .Closing += (s1, e1) => Somewhere(); //disposing logic here
     };
}

Sie müssen vorsichtig mit dem Destruktor sein. Dies wird im GC Finalizer-Thread aufgerufen. In einigen Fällen werden die Ressourcen, die Sie freigeben möchten, möglicherweise nicht in einem anderen Thread veröffentlicht als dem, in dem sie erstellt wurden.

Ich verwende das folgende Interaktivitätsverhalten, um WPF UserControls ein Entladeereignis bereitzustellen. Sie können das Verhalten in die UserControls XAML aufnehmen. So können Sie die Funktionalität nutzen, ohne die Logik in jedes einzelne UserControl zu setzen.

XAML-Erklärung:

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"

<i:Interaction.Behaviors>
    <behaviors:UserControlSupportsUnloadingEventBehavior UserControlClosing="UserControlClosingHandler" />
</i:Interaction.Behaviors>

CodeBehind-Handler:

private void UserControlClosingHandler(object sender, EventArgs e)
{
    // to unloading stuff here
}

Verhaltenscode:

/// <summary>
/// This behavior raises an event when the containing window of a <see cref="UserControl"/> is closing.
/// </summary>
public class UserControlSupportsUnloadingEventBehavior : System.Windows.Interactivity.Behavior<UserControl>
{
    protected override void OnAttached()
    {
        AssociatedObject.Loaded += UserControlLoadedHandler;
    }

    protected override void OnDetaching()
    {
        AssociatedObject.Loaded -= UserControlLoadedHandler;
        var window = Window.GetWindow(AssociatedObject);
        if (window != null)
            window.Closing -= WindowClosingHandler;
    }

    /// <summary>
    /// Registers to the containing windows Closing event when the UserControl is loaded.
    /// </summary>
    private void UserControlLoadedHandler(object sender, RoutedEventArgs e)
    {
        var window = Window.GetWindow(AssociatedObject);
        if (window == null)
            throw new Exception(
                "The UserControl {0} is not contained within a Window. The UserControlSupportsUnloadingEventBehavior cannot be used."
                    .FormatWith(AssociatedObject.GetType().Name));

        window.Closing += WindowClosingHandler;
    }

    /// <summary>
    /// The containing window is closing, raise the UserControlClosing event.
    /// </summary>
    private void WindowClosingHandler(object sender, CancelEventArgs e)
    {
        OnUserControlClosing();
    }

    /// <summary>
    /// This event will be raised when the containing window of the associated <see cref="UserControl"/> is closing.
    /// </summary>
    public event EventHandler UserControlClosing;

    protected virtual void OnUserControlClosing()
    {
        var handler = UserControlClosing;
        if (handler != null) 
            handler(this, EventArgs.Empty);
    }
}

Mein Szenario ist wenig anders, aber die Absicht ist dieselbe. Ich möchte wissen, wann das übergeordnete Fenster, in dem sich mein Benutzersteuerelement befindet, geschlossen / geschlossen wird, da die Ansicht (dh meine Benutzersteuerung) die Präsentatoren oncloseView aufrufen sollte, um einige Funktionen auszuführen und eine Bereinigung durchzuführen. (Nun, wir implementieren ein MVP-Muster in einer WPF PRISM-Anwendung.)

Ich habe gerade herausgefunden, dass ich im Loaded-Ereignis der Benutzersteuerung meine ParentWindowClosing-Methode mit dem Closing-Ereignis des übergeordneten Fensters verbinden kann. Auf diese Weise kann meine Benutzersteuerung erkennen, wann das übergeordnete Fenster geschlossen wird, und entsprechend handeln!

Ich denke, das Entladen wird in 4.7 als alles andere als schwer bezeichnet. Wenn Sie jedoch mit älteren Versionen von .Net herumspielen, versuchen Sie dies in Ihrer Lademethode:

e.Handled = true;

Ich glaube nicht, dass ältere Versionen entladen werden, bis das Laden erledigt ist. Ich poste nur, weil ich sehe, dass andere diese Frage immer noch stellen und dies nicht als Lösung angesehen haben. Ich berühre .Net nur ein paar Mal im Jahr und bin vor ein paar Jahren darauf gestoßen. Aber ich frage mich, ob es so einfach ist, dass das Entladen erst nach Abschluss des Ladevorgangs aufgerufen wird. Scheint, als würde es bei mir funktionieren, aber auch in neueren .Nets scheint es immer Unload aufzurufen, selbst wenn das Laden nicht als behandelt markiert ist.

Ein UserControl hat einen Destruktor. Warum benutzt du das nicht?

~MyWpfControl()
    {
        // Dispose of any Disposable items here
    }