Élimination des contrôles utilisateur WPF

J'ai créé un contrôle utilisateur WPF personnalisé destiné à être utilisé par un tiers. Mon contrôle a un membre privé qui est jetable, et je voudrais m'assurer que sa méthode dispose sera toujours appelée une fois que la fenêtre / l'application contenant est fermée. Cependant, UserControl n'est pas jetable. J'ai essayé d'implémenter l'interface IDisposable et de m'abonner à l'événement Unloaded, mais je ne suis pas appelé lorsque l'application hôte se ferme. Dans la mesure du possible, je ne veux pas que les consommateurs de mon contrôle se souviennent d'appeler une méthode Dispose spécifique.

 public partial class MyWpfControl : UserControl
 {
     SomeDisposableObject x;

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

     }
 }

La seule solution que j'ai trouvée jusqu'à présent est de souscrire à l'événement ShutdownStarted du Dispatcher. Est-ce une approche raisonnable?

this.Dispatcher.ShutdownStarted += Dispatcher_ShutdownStarted;

Article de blog intéressant ici:

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

Il mentionne l'abonnement à Dispatcher.ShutdownStarted pour disposer de vos ressources.

Dispatcher.ShutdownStartedL'événement est déclenché uniquement à la fin de l'application. Cela vaut la peine d'appeler la logique d'élimination au moment où le contrôle devient inutilisable. En particulier, il libère des ressources lorsque le contrôle est utilisé plusieurs fois pendant l'exécution de l'application. La solution d' ioWint est donc préférable. Voici le 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
     };
}

Vous devez être prudent en utilisant le destructeur. Cela sera appelé sur le thread GC Finalizer. Dans certains cas, les ressources que vous libérez peuvent ne pas aimer être publiées sur un thread différent de celui sur lequel elles ont été créées.

J'utilise le comportement d'interactivité suivant pour fournir un événement de déchargement à WPF UserControls. Vous pouvez inclure le comportement dans le UserControls XAML. Ainsi, vous pouvez avoir la fonctionnalité sans placer la logique dans chaque UserControl.

Déclaration XAML:

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

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

Gestionnaire CodeBehind:

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

Code de comportement:

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

Mon scénario est un peu différent, mais l'intention est la même.Je voudrais savoir quand la fenêtre parent hébergeant mon contrôle utilisateur se ferme / se ferme car la vue (c'est-à-dire mon contrôle utilisateur) devrait invoquer les présentateurs oncloseView pour exécuter certaines fonctionnalités et effectuer le nettoyage. (Eh bien, nous implémentons un modèle MVP sur une application WPF PRISM).

Je viens de comprendre que dans l'événement Loaded du contrôle utilisateur, je peux connecter ma méthode ParentWindowClosing à l'événement Parent windows Closing. De cette façon, mon Usercontrol peut être conscient de la fermeture de la fenêtre Parent et agir en conséquence!

Je pense que le déchargement est appelé tout, mais il existe vraiment en 4.7. Mais, si vous jouez avec des versions plus anciennes de .Net, essayez de le faire dans votre méthode de chargement:

e.Handled = true;

Je ne pense pas que les anciennes versions se déchargeront tant que le chargement ne sera pas géré. Je publie simplement parce que je vois que d'autres posent encore cette question et que je n'ai pas vu cela proposé comme une solution. Je ne touche .Net que quelques fois par an, et je suis tombé dessus il y a quelques années. Mais, je me demande si c'est aussi simple que déchargement de ne pas être appelé tant que le chargement n'est pas terminé. On dirait que cela fonctionne pour moi, mais encore une fois dans .Net plus récent, il semble toujours appeler unload même si le chargement n'est pas marqué comme géré.

Un UserControl a un Destructor, pourquoi ne l'utilisez-vous pas?

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