C# Débarrasser de l'objet après l'utilisation de la liste?

J'ai une classe et cette classe a de la "valeur" de la variable contient une grande lecture de données à partir de fichier :

 public class MyClass : IDisposable
{
    public string name {get; set;}
    public string value {get; set;} //I'm load huge data for this variable

    public MyClass(string name, string value)
    {
        this.name = name;
        this.value = value;
    }

    public void Execute()
    {
        Console.WriteLine(this.name + ":" + this.value);
    }

    public void Dispose()
    {
        Dispose(true);            
        GC.SuppressFinalize(this); 
    }

    protected virtual void Dispose(bool disposing)
    {                     
        if (disposing)
        {
            this.name = null;
            this.value = null;
        }                      
    }
}

Et je suis à l'aide de cette classe dans la liste, c'est variable globale

List<MyClass> listQ = new List<MyClass>() { new MyClass("1", "BIGDATA1"),
            new MyClass("2", "BIGDATA2"),
            new MyClass("3", "BIGDATA3"),
            new MyClass("4", "BIGDATA4"),
            new MyClass("5", "BIGDATA5"),
            new MyClass("6", "BIGDATA6"),
        };

    private void FUC_Load(object sender, EventArgs e)
    {                        
        foreach (MyClass m in listQ)
        {
            m.Execute();
            m.Dispose();
        }                       
    }

Donc je veux demander que si je fais comme ça, auront aucun problème? Mon objet sera éliminé ou pas? Toute la meilleure façon de faire? Merci!

Votre classe n'a pas besoin de IDisposable.
Aussi, si vous êtes vraiment ne gardant que le Nom et la Valeur des membres, qui sont des chaînes de caractères, vous pouvez mieux hériter de NameValueCollection plutôt que de réinventer la roue.

OriginalL'auteur Hùng Lê Xuân | 2013-04-28

  1. 8

    C'est une mauvaise utilisation de Dispose().

    Dispose() est conçu pour être utilisé dans deux cas:

    1. Lorsque vous vous débarrassez des ressources non managées.
    2. Lorsque vous supprimer un objet d'un type qui lui-même met en œuvre IDisposable.

    Vous devez renommer votre Dispose() méthode pour être quelque chose comme Clear() pour mieux décrire ce qui se passe.

    Alternativement (et je pense que probablement mieux dans votre cas), vous pouvez simplement définir le listQ référence à null une fois que vous avez itéré. Puisque vous en train de détruire les données qu'il détient en vous parcourez plus de cela, il est clair que vous n'avez pas besoin de les données par la suite.

    Si vous définissez la listQ référence à null, toute sa mémoire, y compris celle de tous les objets qu'il contient des références à l', sera (éventuellement) être récupérées, en supposant que rien d'autre ne détient références à ces objets.

    Noter que vous devrez assurez-vous que tous références à listQ sont nulles. (Références sur la pile disparaît automatiquement lorsque la méthode qu'elles sont déclarées en retour, de sorte que vous n'avez pas besoin de vous soucier de ceux-ci.)

    Je vous remercie beaucoup. Vous êtes sauver ma vie

    OriginalL'auteur Matthew Watson

  2. 1

    Je suppose que vous êtes vraiment inquiet pour les objets de manger en haut de votre mémoire.Vous n'avez pas à moins d'utiliser des ressources non managées comme un accès à un réseau ou à distance ressource de base de données.Puisque ce n'est pas votre cas,l'exécution est assez intelligent pour libérer les ressources lorsqu'il l'estime nécessaire.

    La collecte des ordures .net runtime gère la gestion de ressources pour vous et vous ne devriez pas être inquiet trop sur de libérer votre géré poignées.

    Lorsque votre Liste de référence est hors de portée ou lorsque le GC sait que cette liste n'est pas utilisé ,l'objet sera effacé de la mémoire.

    OriginalL'auteur Prabhu Murthy

  3. 1

    Si possible, utilisez la File d'attente de la classe au lieu de la Liste. De cette façon, lorsque vous Retirer, vous automatiquement de supprimer l'objet de la collection:

    while(queueCollection.Count > 0) {
    MyClass obj = queueCollection.Dequeue();
    obj.Execute();
}

    OriginalL'auteur Tony U.

  4. -1

    L'interface IDisposable est pour la finalisation déterministe.

    Il a commencé comme un moyen de libérer des ressources non managées mais de nos jours, est couramment utilisé pour aussi finalisation d'objets gérés.

    La finalisation ne veut pas dire libérant l'objet. C'est juste une manifestation de votre intention de ne pas utiliser l'objet.

    Si votre objet prend en charge Ouvrir/Fermer, cela devrait signifier que vous pouvez l'ouvrir et le fermer plusieurs fois. Dans ce cas, Jetez devrait appeler Close (ou la même), mais l'objet est inutilisable plus.

    De nombreuses implémentations de IDisposable ont une logique supplémentaire pour contrôler si l'objet a été éliminé et un événement lorsque l'objet est supprimé. Cet événement est souvent utilisé pour supprimer l'objet de collections, il a été ajouté.

    L'objet lui-même ne cesse d'exister lorsque le garbage collector libère.

    OriginalL'auteur Paulo Morgado