Best way to dispose a list

Question

I am having List object. How can I dispose of the list?

For example,

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

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

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

If I set userCollection = null; what will happen?

foreach(User user in userCollection)
{
    user = null;
}

Which one is best?

Solution 1

Best idea is to leave it to the garbage collector. Your foreach will do nothing since only the reference will be set to null not the element in the list. Setting the list to null could in fact cause garbage collection to occur later than it could have (see this post C#: should object variables be assigned to null?).

Solution 2

I don't agree that you shouldn't do anything if you don't need the objects in the list anymore. If the objects implement the interface System.IDisposable then the designer of the object thought that the object holds scarce resources.

If you don't need the object anymore and just assign null to the object, then these scarce resources are not freed until the garbage collector finalizes the object. In the mean time you can't use this resource for something else.

Example: Consider you create a bitmap from a file, and decide you don't need neither the bitmap, nor the file anymore. Code could look like follows:

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.

The good method would be:

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

The same accounts for objects in a list, or any collection. All objects in the collection that are IDisposable should be disposed. Code should be like:

private void EmptySequence (IEnumerable sequence)
{   // throws away all elements in the sequence, if needed disposes them
    foreach (object o in sequence)
    {
        // uses modern pattern-matching
        if (disposableObject is IDisposable disposable)
        {
            disposable.Dispose();
        }
    }
}

Or if you want to create an IEnumerable extension function

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

All lists / dictionaries / read only lists / collections / etc can use these methods, because they all implement IEnumerable interface. You can even use it if not all items in the sequence implement System.IDisposable.

Solution 3

Firstly, you cannot "dispose" a list since it isn't IDisposable, and you can't force it to be collected since that isn't how C# works. Typically you would do nothing here. So when might we need to do anything?

• If it is a method variable, and your method is going to exit in a moment, don't do anything: let the GC worry about it at some point after the method has existed.
• If it is a field (instance variable), and the object is going to go out of scope in a moment, don't do anything: let the GC worry about it at some point after the instance is unreachable.

The only time you need to anything is if it is a field (or captured variable / iterator block variable / etc) and the instance (/delegate/iterator) is going to live a long while longer - then perhaps set the list field to null. Note, however, that if any other code still has a reference to the list then everything will still be reachable.

Solution 4

Another idea for this post... If you were wanting to ensure that all members of a collection are properly disposed, you could use the following extension method:

public static void DisposeAll(this IEnumerable set) {
    foreach (Object obj in set) {
        IDisposable disp = obj as IDisposable;
        if (disp != null) { disp.Dispose(); }
    }
}

This looks through the collection for any member that implements IDisposableand disposing of it. From your executing code, you could clean up the list like this:

usersCollection.DisposeAll();
usersCollection.Clear();

This will ensure that all members get the chance to release resources and the resulting list is empty.

Solution 5

Yet another example of an extension method you can use to dispose a list of objects which implement the IDisposable interface. This one uses LINQ syntax.

    public static void Dispose(this IEnumerable collection)
    {
        foreach (var obj in collection.OfType<IDisposable>())
        {
            obj.Dispose();
        }
    }

View more solutions

Comments

[Kobi]

I didn't vote, but certainly can explain. When is this "Bast" or even needed? Why would you clear a list before throwing away the reference? And why set the reference to null when it is getting out of scope?

[Zhen]

Sure. Don't need to loop yourself.

[Harald Coppoolse]

I don't agree that you shouldn't do anything if you don't need the objects in the list anymore. If the objects implement the System.IDisposable interface then the designer of the object thought that the object holds scarce resources. If you don't need it and just assign null to the object, then these scarce resources are not freed until the garbage collector finalizes the object. In the mean time you can't use this resource for something else.

[Marc Gravell]

@HaraldDutch there's a difference between "disposing the list" and "disposing the items in the list". The list normally has no right to assume that it is the sole owner of those objects.

[Harald Coppoolse]

If you don't dispose a disposable object, its resources are not disposed until the garbage collector finalise the object. If you create a bitmap from a file, and assign null to the bitmap, you can't delete the file because it is still used by the bitmap until it is disposed. Via the finalising of the GC. Therefore you should always Dispose all disposable objects, i stead of just assigning null

[Harald Coppoolse]

You are right, but if your list contains IDisposable objects, then those objects are not Disposed() before the garbage collector finalizes them. If a designer of an object declares the object IDisposable he expresses that it holds some scarce resources that should be frees as soon as possible. Consider a bitmap that is created from file. Even if you assign null to the bitmap, you can't destroy the file before the garbage collector has finalized the bitmap. So you never know when you will be able to delete the file.

[Daniel A.A. Pelsmaeker]

You linked the whole thread. Could you be more specific as to why garbage collection could occur later in this case? Or maybe even quote the relevant paragraph.

[RadioSpace]

@Virtlink - the article states "you could actually wind up extending the time the object stays in memory because the CLR will believe that the object can't be collected until the end of the method because it sees a code reference to the object way down there. "

[Harald Coppoolse]

It depends on the type of objects you store in your collection. If some of them implement IDisposable, the designer wanted to encourage you to call IDisposable.Dispose() instead of just letting the garbage collector do this for you. Usually this is because of scarce resources. For instance if only one object can use a camera at a time, then just assigning null won't free the camera immediately, while calling Dispose() would do this.

[Erwin Mayer]

Does it really make any difference? Isn't the GC intelligent enough to know that usersCollection is no longer used after the foreach loop? In debug mode however, it seems not not be garbage collected.

[Aristos]

@ErwinMayer this is a "trick" from c/c++. Its probably did not matter in normal situations with fast and few code...

[James Moore]

If your list contains IDisposable items, then you have the types wrong. Your list type should itself be an IDisposable.

[Timothy Gonzalez]

The GC does nothing if the OP has a growing list of users.

[Rick the Scapegoat]

I agree with @MarcGravell just because the list has objects, it does not imply it controls them.

[Mick]

I think this answer is upvoted because people like the idea that the magic just happens. I'd agree setting local variables to null is undesirable and likely to create maintainability issues. I'd disagree when setting members to null in IDisposable. There's nothing to back up this claim that setting items to null could actually hamper the garbage collector. With my knowledge of the garbage collectors implementation such a claim seems totally counter intuitive to me.

[Squirrel in training]

Damn @HaraldCoppoolse clean your eddit queue, I can't fix/improve on your extension method!! Anyways ill paste my improvement down here even if it will look really bad /// <summary> /// Iterates over the IEnmuerable and disposes each object /// </summary> public static void DisposeAll<T>(this IEnumerable<T> source) where T : IDisposable { foreach (var disposable in source) { disposable?.Dispose(); }; }