How do you deal with sequences of IDisposable using LINQ?

Question

What's the best approach to call Dispose() on the elements of a sequence?

Suppose there's something like:

IEnumerable<string> locations = ...
var streams = locations.Select ( a => new FileStream ( a , FileMode.Open ) );
var notEmptyStreams = streams.Where ( a => a.Length > 0 );
//from this point on only `notEmptyStreams` will be used/visible
var firstBytes = notEmptyStreams.Select ( a => a.ReadByte () );
var average = firstBytes.Average ();

How do you dispose FileStream instances (as soon as they're no longer needed) while maintaining concise code?

---

To clarify: this is not an actual piece of code, those lines are methods across a set of classes, and FileStream type is also just an example.

---

Is doing something along the lines of:

public static IEnumerable<TSource> Where<TSource> (
            this IEnumerable<TSource> source ,
            Func<TSource , bool> predicate
        )
        where TSource : IDisposable {
    foreach ( var item in source ) {
        if ( predicate ( item ) ) {
            yield return item;
        }
        else {
            item.Dispose ();
        }
    }
}

might be a good idea?

---

Alternatively: do you always solve a very specific scenario with regards to IEnumerable<IDisposable> without trying to generalize? Is it so because having it is an untypical situation? Do you design around having it in the first place? If so, how?

Answer 1

A simple solution is the following:

List<Stream> streams = locations
    .Select(a => new FileStream(a, FileMode.Open))
    .ToList();

try
{
    // Use the streams.
}
finally
{
    foreach (IDisposable stream in streams)
        stream.Dispose();
}

Note that even with this you could in theory still fail to close a stream if one of the FileStream constructors fails after others have already been constructed. To fix that you need to be more careful constructing the inital list:

List<Stream> streams = new List();
try
{
    foreach (string location in locations)
    {
        streams.Add(new FileStream(location, FileMode.Open));
    }

    // Use the streams.
}
finally { /* same as before */ }

It's a lot of code and it's not concise like you wanted but if you want to be sure that all your streams are being closed, even when there are exceptions, then you should do this.

If you want something more LINQ-like you might want to read this article by Marc Gravell:

• SelectMany; combining IDisposable and LINQ

Answer 2

I suggest you turn the streams variable into an Array or a List, because enumerating through it a second time will (if I'm not mistaken) create new copies of the streams.

var streams = locations.Select(a => new FileStream(a, FileMode.Open)).ToList();
// dispose right away of those you won't need
foreach (FileStream stream in streams.Where(a => a.Length == 0))
    stream.Dispose();

var notEmptyStreams = streams.Where(a => a.Length > 0);
// the rest of your code here

foreach (FileStream stream in notEmptyStreams)
    stream.Dispose();

EDIT For these constraints, maybe LINQ isn't the best tool around. Maybe you could get away with a simple foreach loop?

var streams = locations.Select(a => new FileStream(a, FileMode.Open));
int count = 0;
int sum = 0;
foreach (FileStream stream in streams) using (stream)
{
    if (stream.Length == 0) continue;
    count++;
    sum += stream.ReadByte();
}
int average = sum / count;

Answer 3

I would write a method, say, AsDisposableCollection that returns a wrapped IEnumerable which also implements IDisposable, so that you can use the usual using pattern. This is a bit more work (implementation of the method), but you need that only once and then you can use the method nicely (as often as you need):

using(var streams = locations.Select(a => new FileStream(a, FileMode.Open))
                             .AsDisposableCollection()) {
  // ...
} 

The implementation would look roughly like this (it is not complete - just to show the idea):

class DisposableCollection<T> : IDisposable, IEnumerable<T> 
                                where T : IDisposable {
  IEnumerable<T> en; // Wrapped enumerable
  List<T> garbage;   // To keep generated objects

  public DisposableCollection(IEnumerable<T> en) {
    this.en = en;
    this.garbage = new List<T>();
  }
  // Enumerates over all the elements and stores generated
  // elements in a list of garbage (to be disposed)
  public IEnumerator<T> GetEnumerator() { 
    foreach(var o in en) { 
      garbage.Add(o);
      yield return o;
    }
  }
  // Dispose all elements that were generated so far...
  public Dispose() {
    foreach(var o in garbage) o.Dispose();
  }
}