Descartando controles de usuário WPF

Eu criei um controle de usuário WPF personalizado que se destina a ser usado por terceiros. Meu controle tem um membro privado que é descartável e eu gostaria de garantir que seu método de descarte sempre seja chamado assim que a janela / aplicativo contêiner for fechada. No entanto, UserControl não é descartável. Tentei implementar a interface IDisposable e assinar o evento Unloaded, mas não fui chamado quando o aplicativo host é fechado. Se possível, não quero confiar nos consumidores do meu controle lembrando-se de chamar um método Dispose específico.

 public partial class MyWpfControl : UserControl
 {
     SomeDisposableObject x;

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

     }
 }

A única solução que eu encontrei até agora é assinar o evento ShutdownStarted do Dispatcher's. Essa é uma abordagem razoável?

this.Dispatcher.ShutdownStarted += Dispatcher_ShutdownStarted;

Postagem interessante no blog aqui:

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

Menciona assinar Dispatcher.ShutdownStarted para descartar seus recursos.

Dispatcher.ShutdownStartedO evento é acionado apenas no final do aplicativo. Vale a pena chamar a lógica de descarte justamente quando o controle fica fora de uso. Em particular, ele libera recursos quando o controle é usado várias vezes durante o tempo de execução do aplicativo. Portanto , a solução da ioWint é preferível. Aqui está o código:

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

Você precisa ter cuidado ao usar o destruidor. Isso será chamado no thread do Finalizador do GC. Em alguns casos, os recursos em que sua liberação pode não gostar de serem liberados em um encadeamento diferente daquele em que foram criados.

Eu uso o seguinte comportamento de interatividade para fornecer um evento de descarregamento ao WPF UserControls. Você pode incluir o comportamento no UserControls XAML. Assim, você pode ter a funcionalidade sem colocar a lógica em cada UserControl.

Declaração XAML:

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

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

Manipulador CodeBehind:

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

Código de comportamento:

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

Meu cenário é um pouco diferente, mas a intenção é a mesma que eu gostaria de saber quando a janela pai que hospeda o meu controle de usuário está sendo fechada / fechada. (bem, estamos implementando um padrão MVP em um aplicativo WPF PRISM).

Acabei de descobrir que, no evento Loaded do usercontrol, posso conectar meu método ParentWindowClosing ao evento Closing do Windows Parent. Dessa forma, meu controle de usuário pode estar ciente quando a janela principal está sendo fechada e agir em conformidade!

Eu estou pensando que descarregar é chamado tudo, mas dificilmente existe no 4.7. Mas, se você estiver brincando com versões mais antigas do .Net, tente fazer isso no seu método de carregamento:

e.Handled = true;

Eu não acho que as versões mais antigas serão descarregadas até que o carregamento seja tratado. Estou apenas postando porque vejo outras pessoas ainda fazendo essa pergunta, e não a vi proposta como uma solução. Eu toco apenas .Net algumas vezes por ano e me deparei com isso alguns anos atrás. Mas, eu me pergunto se é tão simples quanto descarregar não ser chamado até o carregamento terminar. Parece que funciona para mim, mas novamente no .Net mais recente parece sempre chamar descarregar, mesmo que o carregamento não esteja marcado como tratado.

Um UserControl tem um destruidor, por que você não usa isso?

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