C# comment implémenter la méthode dispose

J'ai besoin de quelques conseils sur la mise en œuvre de la Dispose méthode.

Dans notre application, l'utilisateur conçoit leur propre INTERFACE utilisateur. J'ai une fenêtre d'aperçu qui montre ce que l'INTERFACE utilisateur va ressembler. Tous les objets dessinés dans cette INTERFACE, finalement, dérivent d'une classe de base commune ScreenObject. Mon aperçu du gestionnaire de contenir un objet unique référence à un ScreenGrid qui est l'objet de la grille pour l'ensemble de la zone d'aperçu.

Question #1

Certains de mes dérivé classes d'écran tenir sur des ressources non managées, comme une connexion de base de données, image bitmap et un WebBrowser de contrôle. Ces classes ont besoin de disposer de ces objets. J'ai créé un virtual Dispose méthode dans la base ScreenObject de la classe de base et de mettre en œuvre un remplacement Dispose méthode dans chacune des classes dérivées qui détiennent sur des ressources non managées. Cependant, pour l'instant, je viens de créer une méthode appelée Dispose, je ne suis pas la mise en œuvre de IDisposable. Dois-je mettre en œuvre IDisposable? Si oui, comment dois-je mettre en œuvre?

Seulement sur les classes dérivées qui ont des ressources non managées
La classe de base et les classes dérivées qui ont des ressources non managées OU
La classe de base et de toutes les classes dérivées, y compris ceux qui n'ont pas les ressources non managées

Est-il de mal à mettre un virtuel Dispose méthode dans une classe de base qui n'ont pas les ressources non managées, de sorte que vous pouvez prendre avantage de polymorphisme?

Question #2

À la lecture de la Dispose méthode et la IDisposable interface Microsoft indique que l'élimination de l'objet ne doit appeler la Dispose méthode pour son parent. Le parent doit l'appeler par son parent et ainsi de suite. Pour moi, cela semble en arrière. Je peux avoir envie de se débarrasser d'un enfant, mais de garder son parent autour de.

Je pense qu'elle devrait être dans l'autre sens, un objet en cours de cession doit disposer de ses enfants. Les enfants doivent alors disposer de leurs enfants et ainsi de suite.

Je suis mal ici ou ai-je raté quelque chose?

Pour votre deuxième question. Peut-être que vous avez mal compris quelque chose. Microsoft ne dit que la classe devrait appeler sa classe parent méthode dispose, ce qui signifie que la méthode de la classe de base. Je suis d'accord que la classe seulement se débarrasser de ses enfants et à la fin de sa base.
Avez-vous les ressources non managées dans votre classe? Ou avez-vous juste propre à une classe qui détient à son tour les ressources non managées? J'espère que c'est la deuxième, sinon vous aurez à traiter avec des choses amusantes comme la critique de finalisation.
Question #1: Vous devez mettre en œuvre IDisposable de sorte que vous (et d'autres) peut alors utiliser la using déclaration en C#. Avoir une méthode dispose sans la mise en œuvre de IDisposable n'a pas vraiment de sens, vous pourriez juste l'appeler MyCleanUp ainsi.
Votre classe ScreenObject pourrait également avoir un résumé méthode MyCleanUp à la force de sa mise en œuvre. Avec une bonne documentation, il devrait être clair que implementators avez à faire.
Cela pourrait bien être le 100e double de cette question. Avez-vous la peine, même en regardant la liste des questions similaires?
Oui je vois beaucoup de les mêmes réponses à la même question, mais j'ai expressément demandé à des questions différentes. Comme dans la mise en œuvre lorsque vous traitez avec de la classe dérivée qui détiennent les ressources non managées et mon interprétation erronée de l'appel de jeter sur l'objet parent, pas de la classe parent.
Je pensais exactement, pourquoi ne pas simplement créer une méthode comme MyCleanUp. Comme pour le rendre abstrait, qui ne fonctionne pas comme j'ai beaucoup de classes dérivées sans ressources gérées qui n'ont pas à effectuer le nettoyage. Si j'en œuvre IDisposable ce que toutes les classes doivent implémenter la classe de base, et mes classes dérivées qui détiennent sur des ressources non managées seulement?
L'implémentation de référence sur MSDN n'répondre à l'héritage et tout le reste. Ne pas DIY ici.
Le but de IDisposable n'est pas pour détruire les objets--c'est pour s'assurer qu'ils peuvent être en toute sécurité abandonné. Sauf quand il serait absolument impossible de le faire, chaque objet doit être conçu de sorte qu'il peut être abandonné en toute sécurité si (1) IDisposable.Disposer est appelé en premier, ou (2) il n'est pas de mettre en œuvre IDisposable. Une classe nécessite de nettoyage personnalisés mais ne pas mettre en œuvre IDisposable ne remplit pas l'une des ci-dessus.
double possible de Sera le Garbage Collector appel IDisposable.Disposer de moi?

InformationsquelleAutor WPFNewbie | 2011-09-20

c#dispose

35

Question 1: mettre en Œuvre IDisposable ainsi, selon le modèle suivant:
```
public class MyClass : IDisposable
{
    bool disposed;

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                //dispose managed resources
            }
        }
        //dispose unmanaged resources
        disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}
```
Question 2: est-Ce que Microsoft signifie qu'une classe dérivée appelle dispose sur sa classe parent. Le propriétaire de l'instance uniquement les appels Jeter sur la plupart des dérivés de type.

Un (raccourcie) exemple:
```
class Parent : IDisposable 
{
    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                //dispose managed resources
            }
        }
        //dispose unmanaged resources
        disposed = true;
    }

}
class Child : Parent, IDisposable 
{ 
    protected override void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                //dispose managed resources
            }
            base.Dispose(disposing);
        }
        //dispose unmanaged resources
        disposed = true;
    }

}
class Owner:IDisposable
{
    Child child = new Child();
    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                if(child!=null)
                {
                    child.Dispose();
                }
            }
        }
        //dispose unmanaged ressources
        disposed = true;
    }
}
```
Le propriétaire seuls les appels Dispose sur l'Enfant, mais pas sur le Parent. L'Enfant est responsable de l'appel Dispose sur le Parent.
- FxCop règlement donne un exemple de mise en œuvre de ce cas: msdn.microsoft.com/en-gb/library/ms182330(SV.80).aspx
- Non, l'utilisation de l'élimination modèle est mal 99,9% du temps. Utilisé uniquement si la classe a un finaliseur, il ne devrait pas en avoir un. Envelopper les ressources non managées dans leur propre classe, comme l'un des SafeHandle les classes dérivées.
- Dans votre deuxième réponse, où la déclaration de la non virtuel Disposer méthode sans paramètres, allez? Ma pensée est que vous pouvez les placer dans la classe Parent, ou serait à la fois le Parent et l'Enfant à mettre en œuvre?
- Pas sûr de ce que Hans est la signification, pouvez-vous élaborer? Par exemple, j'ai une classe ScreenPage qui montre une page HTML sur une partie de l'écran. C'est une application WPF et je suis en utilisant le contrôle WebBrowser pour le rendu de la page HTML. Mon ScreenPage classe est dérivée de ScreenParent. Comment suggérez-vous que je me débarrasser de la WebBrowser. Êtes-vous en déclarant que je créer un ScreenWebBrowser classe, qui détient le contrôle WebBrowser et que mon ScreenPanel viens de référence de cette classe? Si oui, je ne vois pas comment cela m'achète quelque chose, j'ai encore besoin d'invoquer la Jeter.
- Je pense que ce que Hans signifie que vous ne devez pas mettre en œuvre un outil de finalisation, sauf si vous avez quelque chose à finaliser, c'est à dire des ressources non managées. Parce que chaque classe qui implémente un finaliseur est placé dans le garbage collector finaliseur de la file d'attente, ce qui entraîne la nécessité de deux GC pistes pour libérer de l'objet. Sans finaliseur il aurait seulement besoin d'une GC exécuter.
- J'irais même plus loin et suggèrent que les classes primordial Finaliser (ou dont le C# destructeurs) à des fins de nettoyage devraient éviter de tenir des références fortes à tous les objets ne sont pas nécessaires pour le nettoyage; si une classe qui permettrait d'utiliser les ressources non managées, dérive d'une classe qui n'a pas les ressources non managées doit être encapsulée à l'intérieur de leur propre classe (qui serait donc une ressource gérée) et de la classe dérivée doit contenir une référence à cela. Il n'y a donc pas de raison de s'inquiéter d'une IDisposable de mise en œuvre prévoyant un dérivé de la classe finaliseur, car il ne devrait pas être.
- Il y a une erreur dans la réponse. Disposer de la méthode ne devrait pas être l'appel de base.Dispose() - qui est à l'origine de débordement de pile. Il devrait plutôt appeler protégé de la base de méthode d'objet, éventuellement de base.Dispose(true)
- Je vous remercie. Je vais les corriger immédiatement.
- Je suggère de déplacer base.Dispose(disposing) dans la classe Enfant à l'extérieur de la if (disposing) bloc logique que la classe Parent contient des ressources non managées et que le bloc est réservé pour libérer les ressources gérées. Si Dispose(false) est appelée sur l'Enfant, étant donné le contexte actuel de mise en œuvre - les ressources non managées que la société Mère détient ne sera pas libéré.
InformationsquelleAutor PVitt
7

Question 1:

Sur la base des types d'objets de la liste (c'est à dire de la Base de données, WebBrowser, Bitmap, etc.) ce ne sont que des géré ressources .NET est concerné. Ainsi, vous devez mettre en œuvre IDisposable sur toute la classe qui a jetables types de membres. S'ils sont déclarés localement cas, il vous suffit d'appeler 'l'aide de ()" sur eux. Bien que ces situations que vous mentionnez n'ont les ressources non managées, sous eux, c'est abstrait, loin de vous par .NET à travers les types que vous utilisez. Depuis que vous utilisez uniquement les types gérés, vous devez mettre en œuvre IDisposable mais sans un finaliseur. Vous avez seulement besoin de mettre en œuvre un finaliseur si vous avez vraiment des ressources non managées en tant que membres de la classe.

Question 2:

Il semble que vous confondez l'héritage (est un) avec l'agrégation/confinement (a une). Par exemple, si "Conteneur" contient une seule ressource en tant que membre de la classe, il est appelé agrégation/confinement. Ainsi, l'appel de base.Dispose() dans le IDisposable mise en œuvre de Conteneur n'a rien à voir avec l'élimination de l'jetables ressources à l'intérieur de de Conteneur. Vous devez vous rappeler que si une classe dérive de Conteneur, dire "DerivedContainer", qu'il est une instance du Conteneur, mais avec d'autres membres et/ou les fonctionnalités. De sorte que toute instance de "DerivedContainer" a tous les membres de sa classe de base "Conteneur" ne. Si vous n'avez jamais appelé base.Dispose(), le jetable ressource "Conteneur" ne serait pas libéré correctement (il serait effectivement par le GC, mais c'est une mauvaise pratique pour de nombreuses raisons, à juste " de laisser .NET prendre soin d'elle') - veuillez vous référer à mon posté réponse à Est-ce une mauvaise pratique de dépend du .NET automatisé garbage collector?.

Si vous n'avez pas d'appel de la classe de base Dispose(), vous finirais avec un partiellement éliminés objet (disposé dans la classe dérivée, mais pas dans la classe de base) - un très mauvais scénario. Il est donc très important d'appeler la classe de base Dispose().

J'ai de bonnes pratiques modèle que j'ai développé (avec beaucoup d'expérience et de débogage des vidages de mémoire) écrit sur mon blog comme un exemple. Il montre comment mettre en œuvre IDisposable sur une classe de base ainsi que d'une classe dérivée:

http://dave-black.blogspot.com/2011/03/how-do-you-properly-implement.html
- La question était assez vieux par le temps que vous avez répondu. J'ai pris un coup d'oeil à votre blog, si. Vous semblent répéter la normale Microsoft modèle, les défauts et tous. Entre autres choses, plutôt que d'utiliser un drapeau pour fournir thread-safe protection contre les multi-disposition pour toutes les classes dérivées, il exige un drapeau pour chaque classe dérivée et n'est pas thread-safe. Aussi, étant donné que les classes avec les finaliseurs devrait éviter de tenir des objets ne sont pas nécessaires pour la finalisation, les classes dérivées shoudln pas tenir des ressources non managées si la classe de base ne fonctionne pas.
- Je suis confus par votre commentaire... j'ai répondu seulement 3 mois après que la question a été posée - ce n'est certainement pas "très vieux". Mon profil est différent de Microsoft modèle. J'ai plus de précautions de sécurité, d'inclure des exemples de disposition des objets managés dans la méthode dispose, ajouter des commentaires sur si vous devez utiliser un outil de finalisation, commentaires sur quand vous pourriez avoir besoin pour mettre en œuvre la synchronisation des threads. C'est une mauvaise pratique d'inclure la synchronisation des threads si vous n'avez pas besoin. Aussi, merci de m'éclairer sur les "défauts" à laquelle vous vous référez.
InformationsquelleAutor Dave Black

- Je Mettre En Œuvre IDisposable

 class ConnectionConfiguration:IDisposable
{
    private static volatile IConnection _rbMqconnection;
    private static readonly object ConnectionLock = new object();
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    protected virtual void Dispose(bool disposing)
    {
        if (!disposing)
        {
            return;
        }
        if (_rbMqconnection == null)
        {
            return;
        }
        lock (ConnectionLock)
        {
            if (_rbMqconnection == null)
            {
                return;
            }
            _rbMqconnection?.Dispose();//double check
            _rbMqconnection = null;
        }
    }
}

pouvez-vous expliquer pourquoi avez-vous utilisé une double vérification de ici.

InformationsquelleAutor Sunil Dhappadhule

Vous devez vous connecter pour publier un commentaire.

Question 1:

Question 2: