Usuwanie formantów użytkownika WPF

Utworzyłem niestandardową kontrolkę użytkownika WPF, która jest przeznaczona do użytku przez inną firmę. Mój formant ma prywatnego członka, który jest jednorazowy i chciałbym mieć pewność, że jego metoda usuwania będzie zawsze wywoływana po zamknięciu zawierającego okno / aplikacji. Jednak UserControl nie jest jednorazowy. Próbowałem zaimplementować interfejs IDisposable i subskrybować zdarzenie Unloaded, ale żadne z nich nie jest wywoływane po zamknięciu aplikacji hosta. Jeśli to w ogóle możliwe, nie chcę polegać na konsumentach mojej kontroli, którzy pamiętają o wywołaniu określonej metody Dispose.

 public partial class MyWpfControl : UserControl
 {
     SomeDisposableObject x;

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

     }
 }

Jedynym rozwiązaniem, jakie do tej pory znalazłem, jest zasubskrybowanie zdarzenia ShutdownStarted Dispatchera. Czy to rozsądne podejście?

this.Dispatcher.ShutdownStarted += Dispatcher_ShutdownStarted;

Ciekawy wpis na blogu tutaj:

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

Wspomina o subskrybowaniu Dispatcher.ShutdownStarted w celu pozbycia się zasobów.

Dispatcher.ShutdownStartedzdarzenie jest uruchamiane tylko na końcu aplikacji. Warto wywołać logikę usuwania właśnie wtedy, gdy kontrola przestanie być używana. W szczególności zwalnia zasoby, gdy sterowanie jest używane wielokrotnie podczas działania aplikacji. Dlatego preferowane jest rozwiązanie ioWint . Oto kod:

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
     };
}

Z destruktorem trzeba uważać. Zostanie to wywołane w wątku GC Finalizer. W niektórych przypadkach zasoby, które uwolniłeś, mogą nie być zwolnione w innym wątku niż ten, w którym zostały utworzone.

Używam następującego zachowania interaktywności, aby zapewnić zdarzenie zwalniania do WPF UserControls. Możesz uwzględnić zachowanie w kodzie XAML UserControls. Możesz więc mieć tę funkcjonalność bez umieszczania jej logiki w każdym pojedynczym UserControl.

Deklaracja XAML:

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

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

Procedura obsługi CodeBehind:

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

Kod zachowania:

/// <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);
    }
}

Mój scenariusz jest trochę inny, ale intencja jest taka sama. Chciałbym wiedzieć, kiedy okno nadrzędne, w którym znajduje się moja kontrolka użytkownika, jest zamykane / zamykane, ponieważ widok (tj. Moja kontrola użytkownika) powinien wywoływać osoby prowadzące oncloseView, aby wykonać pewne funkcje i przeprowadzić czyszczenie. (cóż, implementujemy wzorzec MVP w aplikacji WPF PRISM).

Właśnie doszedłem do wniosku, że w zdarzeniu Loaded kontrolki użytkownika mogę podłączyć moją metodę ParentWindowClosing do zdarzenia Zamykanie okien nadrzędnych. W ten sposób moja kontrola użytkownika może być świadoma, kiedy okno rodzica jest zamykane i odpowiednio działać!

Myślę, że rozładowanie nazywa się wszystko, ale ciężko istnieje w 4.7. Ale jeśli bawisz się starszymi wersjami .Net, spróbuj zrobić to w swojej metodzie ładowania:

e.Handled = true;

Nie sądzę, aby starsze wersje rozładowały się, dopóki ładowanie nie zostanie obsłużone. Po prostu publikuję, ponieważ widzę, że inni nadal zadają to pytanie i nie widziałem tego proponowanego jako rozwiązania. Dotykam .Net tylko kilka razy w roku i wpadałem na to kilka lat temu. Ale zastanawiam się, czy jest to tak proste, jak nie wywoływanie wyładowania przed zakończeniem ładowania. Wydaje się, że to działa dla mnie, ale znowu w nowszej .Net wydaje się, że zawsze wywołuje unload, nawet jeśli ładowanie nie jest oznaczone jako obsługiwane.

UserControl ma Destructor, dlaczego tego nie użyjesz?

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