Smaltimento dei controlli utente WPF

Question

Ho creato un controllo utente WPF personalizzato che è destinato ad essere utilizzato da una terza parte. Il mio controllo ha un membro privato che è usa e getta, e mi piacerebbe assicurarmi che il suo metodo di eliminazione venga sempre chiamato una volta chiusa la finestra o l'applicazione contenente. Tuttavia, UserControl non è usa e getta. Ho provato a implementare l'interfaccia IDisposable e ad iscrivermi all'evento Unloaded, ma nessuno dei due viene chiamato quando l'applicazione host si chiude. Se possibile, non voglio fare affidamento sui consumatori del mio controllo ricordando di chiamare un metodo Dispose specifico.

public partial class MyWpfControl : UserControl 
{ 
    SomeDisposableObject x; 

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

    } 
} 

L'unica soluzione che ho trovato finora è iscriversi all'evento ShutdownStarted del Dispatcher. È un approccio ragionevole?

this.Dispatcher.ShutdownStarted += Dispatcher_ShutdownStarted; 

Answer 1

interessante post sul blog qui:

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

si menziona la sottoscrizione di Dispatcher_ShutDownStarted di disporre delle vostre risorse.

Answer 2

Un UserControl ha un Destructor, perché non lo usi?

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

Answer 3

bisogna essere attenti usando il distruttore. Questo verrà chiamato sul thread di GC Finalizer. In alcuni casi, le risorse a cui la tua liberazione potrebbe non piacere vengono pubblicate su un thread diverso da quello in cui sono state create.

Answer 4

Il mio scenario è leggermente diverso, ma l'intento è lo stesso vorrei sapere quando la finestra padre che ospita il mio controllo utente è chiusa/chiusa come La vista (cioè il mio usercontrol) dovrebbe invocare i presentatori oncloseView per eseguire alcune funzionalità e eseguire la pulizia. (beh stiamo implementando un pattern MVP su un'applicazione PRISM WPF).

Ho appena capito che nell'evento Loaded dell'usercontrol, posso collegare il mio metodo ParentWindowClosing all'evento Closing di Windows padre. In questo modo il mio Usercontrol può essere consapevole quando la finestra Genitore viene chiusa e agisce di conseguenza!

Answer 5

Dispatcher.ShutdownStarted l'evento viene generato solo alla fine dell'applicazione. Vale la pena di chiamare la logica di smaltimento proprio quando il controllo diventa inutilizzabile. In particolare, libera le risorse quando il controllo viene utilizzato più volte durante il runtime dell'applicazione. Quindi è preferibile la soluzione ioWint. Ecco il codice:

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

Answer 6

Io uso il seguente comportamento interattività per fornire un evento di scarico per controlli utente WPF. È possibile includere il comportamento in UserControls XAML. Così puoi avere la funzionalità senza posizionarla in ogni singolo UserControl.

dichiarazione XAML:

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

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

gestore CodeBehind:

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

Codice di 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); 
    } 
}