La meilleure façon de disposer d'une liste

Meilleure idée est de laisser le garbage collector.
Votre foreach ne changera rien puisque seule la référence sera définie à null pas l'élément dans la liste. Réglage de la liste de null pourrait en fait causer la collecte des ordures à se produire plus tard qu'elle pourrait avoir (voir ce post C#: doit variables d'objet être assignée à null?).

Je ne suis pas d'accord que vous ne devriez pas faire quoi que ce soit si vous n'avez pas besoin de les objets dans la liste. Si les objets implémentent l'interface System.IDisposable ensuite, le concepteur de l'objet pensé que l'objet contient des ressources rares.

Si vous n'avez pas besoin de l'objet et plus seulement affecter null à l'objet, ces ressources ne sont pas libérés jusqu'à ce que le garbage collector finalise l'objet. Dans le même temps, vous ne pouvez pas utiliser cette ressource pour quelque chose d'autre.

Exemple:
Envisagez-vous de créer une image à partir d'un fichier, et décidez que vous n'avez pas besoin ni l'image, ni le fichier plus. Le Code pourrait ressembler à la suivante:

using System.Drawing;
Bitmap bmp = new Bitmap(fileName);
... //do something with bmp until not needed anymore
bmp = null;
File.Delete(fileName); //EXCEPTION, filename is still accessed by bmp.

La bonne méthode serait:

bmp.Dispose();
bmp = null;
File.Delete(fileName);

Les mêmes comptes pour les objets dans une liste, ou n'importe quelle collection. Tous les objets de la collection sont IDisposable doivent être éliminés. Le Code devrait ressembler à:

private void EmptySequence (IEnumerable sequence)
{   //throws away all elements in the sequence, if needed disposes them
    foreach (object o in sequence)
    {
        System.IDisposable disposableObject = o as System.IDisposable;
        o = null;
        if (disposableObject != null)
        {
            disposableObject.Dispose();
        }
    }
}

Ou si vous souhaitez créer un IEnumerable fonction d'extension

public static void DisposeSequence<T>(this IEnumerable<T> source)
{
    foreach (IDisposable disposableObject in source.OfType(System.IDisposable))
    {
        disposableObject.Dispose();
    };
}

Toutes les listes /dictionnaires /lecture seule listes /collections /etc pouvez utiliser ces méthodes, parce qu'ils implémentent l'interface IEnumerable. Vous pouvez même l'utiliser si pas tous les éléments de la séquence de mettre en œuvre le Système.IDisposable.

Vous n'avez pas fourni suffisamment de contexte. La portée est ici essentielle.

Je pense que le GC doit être suffisamment intelligente pour gérer la mémoire allouée pour les utilisateurs et la collection sans avoir à régler quoi que ce soit à null.

Si la collection supprime des utilisateurs qui ne sont pas nécessaires à partir de la collection, et pas les autres objets se réfèrent à eux, ils seront GC avais sans que vous ayez à fournir des indices.

Le GC ne pas nettoyer un objet tant qu'il y aura un live de référence. Éliminer toutes les références et qu'il puisse faire son travail.

Meilleure façon est

userCollection= null;

Que GC prendra soin du reste.

Il y a une bien meilleure manière lors de l'utilisation Système.Réactive.Disposeables:

Initialiser une nouvelle propriété de type CompositeDisposable et à ajouter les articles à usage unique à cette collection. Alors jetez juste un.

Voici un exemple de code comment le faire dans un typique WPF/UWP ViewModel sans indroducing tout fuites de mémoire:

public sealed MyViewModel : IDisposable
{
    //ie. using Serilog
    private ILogger Log => Log.ForContext<MyViewModel>();

    //ie. using ReactiveProperty 
    public ReactiveProperty<string> MyValue1 { get; } 
        = new ReactiveProperty<string>(string.Empty);

    public ReactiveProperty<string> MyValue1 { get; } 
        = new ReactiveProperty<string>(string.Empty);

    //this is basically an ICollection<IDisposable>
    private CompositeDisposable Subscriptions { get; } 
        = new CompositeDisposable();

    public MyViewModel()
    {
        var subscriptions = SubscribeToValues(); //Query
        Subscriptions.AddRange(subscriptions); //Command
    }

    private IEnumerable<IDisposable> SubscribeToValues()
    {
        yield return MyValue1.Subscribe(
            value => DoSomething1(value), 
            ex => Log.Error(ex, ex.Message), 
            () => OnCompleted()); 

        yield return MyValue2.Subscribe(
            value => DoSomething2(value),
            ex => Log.Error(ex, ex.Message), 
            () => OnCompleted()); 
    }

    private void DoSomething1(string value){ /* ... */ }
    private void DoSomething2(string value){ /* ... */ }
    private void OnCompleted() { /* ... */ }

mettre en œuvre IDisposable comme ceci:

    #region IDisposable
    private ~MyViewModel()
    {
        Dispose(false);
    }

    public void Dispose()
    {
        Dispose(true);
    }

    private bool _isDisposed;
    private Dispose(bool disposing)
    {
        if(_isDisposed) return; //prevent double disposing

        //dispose values first, such that they call 
        //the onCompleted() delegate
        MyValue1.Dispose();
        MyValue2.Dispose();

        //dispose all subscriptions at once 
        Subscriptions.Dispose(); 

        //do not suppress finalizer when called from finalizer
        if(disposing) 
        {
            //do not call finalizer when already disposed
            GC.SuppressFinalize(this);
        }
        _isDisposed = true;
    }
    #endregion
}

et ici, c'est la classe d'extension pour obtenir le .AddRange() méthode:

public static class CollectionExtensions
{
    public static void AddRange<T>(this ICollection<T> collection, IEnumerable<T> values)
    {
        foreach(var value in values)
        {
            collection.Add(value);
        }
    }
}

Voir aussi

• BooleanDisposable vous permet d'interroger si l'objet a déjà obtenu éliminés
• CancellationDisposable est comme BooleanDisposable mais avec un jeton d'annulation
• ContextDisposable vous permet de disposer dans un contexte de thread
• MultipleAssignmentDisposable remplace un jetable avec un autre sans se débarrasser de la vieille jetables
• SerialDisposable remplace le vieux disposalbe avec l'autre, tandis que l'élimination de l'ancien jetables
• SingleAssignmentDisposable magasins d'un revenu qui ne peuvent pas replaed avec un autre jetables

Pourquoi voulez-vous de disposer de la liste? Le GC va le faire pour vous si il n'y a pas de références à elle.

La Collecte Des Ordures: msdn.microsoft.com/en-us/library/0xy59wtx.aspx

Une autre idée est d'utiliser des crochets qui comprennent la portée de la variable que vous souhaitez garder.

par exemple.

void Function()
{
    ... some code here ....

    {   //inside this bracket the usersCollection is alive
        //at the end of the bracet the garbage collector can take care of it

        List<User> usersCollection =new List<User>();

        User user1 = new User();
        User user2 = new User()

        userCollection.Add(user1);
        userCollection.Add(user2);

        foreach(User user in userCollection)
        {

        }
    }

    ... other code here ....
}

Je vois beaucoup de réponses à l'appel de Disposer d'un objet à l'intérieur d'une boucle foreach sur une collection.
Depuis Jetez simplement les marques de l'objet à supprimé la prochaine fois que le garbage collector est exécuté, il va travailler sur ok. En théorie cependant, l'élimination d'un élément susceptible de modifier la collecte et la rupture de la boucle foreach, de sorte qu'il serait plus robuste d'abord recueillir ces objets jetables, effacer la liste d'origine, et l'appel de la jeter dans une pour ou en boucle à partir de la fin et de retrait de l'objet à chaque itération, par exemple, l'appel de la méthode suivante:

    public static void DisposeItemsInList<T>(this IList<T> list) where T : IDisposable
    {
        DeleteItemsInList(list, item => item.Dispose());
    }

    public static void DeleteItemsInList<T>(this ICollection<T> list, Action<T> delete)
    {
        if (list is IList && !((IList)list).IsFixedSize)
        {
            while (list.Count > 0)
            {
                T last = list.Last();
                list.Remove(last);
                delete?.Invoke(last);
            }
        }
        else
        {
            for (int i = 0; i < list.Count; i++)
            {
                delete?.Invoke(list.ElementAt(i));
            }
        }
    }

Je suis en train de l'utiliser DeleteItemsInList pour d'autres fins, par exemple pour supprimer les fichiers: DeleteItemsInList(Fichier.Delete) )

Que ceux qui ont déclaré, dans le cas général, il ne devrait pas être nécessaire de disposer d'une telle liste.
Un cas où je dois disposer d'un élément dans une liste est de travailler avec le Ruisseau, je collectionne un peu cuit à la vapeur, de transformer les données, puis débarrassez-vous de ces flux et de ne garder que mes objets transformés pour la poursuite du traitement.

Si votre article dans la liste est géré par les nations unies de l'objet, alors vous pouvez appeler dispose() de chaque objet par l'itération d'elle.

foreach(User user in userCollection)
{
user.Dispose();
}

Si l'objet de liste d'objet géré, alors vous n'avez rien à faire. GC prendra soin.