La compréhension des objets jetables

L'approche normale est d'appliquer la standard IDispoable mise en œuvre - CEPENDANT cela est vraiment nécessaire uniquement si votre classe ou d'une classe qui dérive de la volonté d'utiliser les ressources non managées - ce cas est en effet TRÈS rare (et quand ce cas s'applique, il est préférable d'envelopper le non géré ressource dans sa propre classe qui a un standard complet IDisposable mise en œuvre).

Donc, en supposant que vous n'avez pas affaire avec des ressources non managées (fichier raw poignées, à l'échelle mondiale alloced de mémoire, etc) et de ne travailler qu'avec des membres qui sont jetables (j'.e qui ont géré les ressources et de mettre en œuvre IDisposable), alors vous pouvez en toute sécurité avec un mimimal implémentation de IDispose - qui est:

Juste un seul void dispose() de la méthode. Dans la méthode appelez simplement disposer sur dispoable membres et puis les Disposer sur la classe de base si son jetables. Si vous avez une hiérarchie de classe que son ok pour faire de ce Jeter virtuel. Il n'est pas nécessaire d'avoir une méthode dispose(bool). Ni est-il besoin de vérifier si l'objet est disposé - parce que tout votre faire est d'appeler dipsose sur d'autres objets, et de la mise en œuvre fera que vérifier.

Si vous n'aimez pas le mimimal appraoch puis appliquer le standard implimentation (mais il n'est pas strictement nécessaire). I. e soit faire un standard de implimentation parce que votre cheval pour la suite de l'approche recommandée OU de faire une simple minime (mais correct) mise en œuvre - mais ne pas faire quelque chose entre les deux (j'.e pas de norme, pas simple ou non correcte)!

Voir cette question pour plus de détails: Minimes IDispose implimenation à la gestion des ressources

Si dans votre cas, ce qui suit est la mimimal implimentation:

public class SuperObject : IDisposable {
    public void Dispose() {
        //Dispose code...just call dispose on dispoable members.
        //If there are none then no need to implement IDisposable!
    }
}

public interface ICustom : IDisposable { }
public class Custom : ICustom {
    public SuperObject Super { get; protected set; }

    public Custom() {
        Super = new SuperObject();
    }

    public void Dispose() {
        if (Super != null)
            Super.Dispose();
    }
}  

public class Moo : Controller {
    Custom c;

    public Moo() {
        c = new Custom();
    }

    public Dispose() {
        if (c!=null)
            c.Dispose()
        base.Dispose();       
    }
}

Noter que si le Super objet n'a pas de ressources jetables alors il n'y a pas de point dans la mise en œuvre IDisposable et d'avoir une méthode dispose. Si les Douanes seulement jetables objet est SuperObject puis en va de même là, et de nouveau la même logique des pierres sur Moo. Enfin alors si tous les ci-dessus s'applique et il n'y a pas d'autres objets jetables autour de tout ce que vous devez vraiment besoin est:

  public class Moo : Controller {
        Custom c;

        public Moo() {
            c = new Custom();
        }

        public Dispose() {
           base.Dispose();       
        }
    }

OriginalL'auteur Ricibob