Avoiding nested using blocks when outer is used only to construct inner

Question

Often, the IDisposable object of a using block is itself constructed from another IDisposable object, e.g.

using (FileStream stream = File.Open(path, FileMode.Open))
using (MyObject obj = new MyObject(stream))
{
  // do something with obj
}

Unfortunately the code above keeps the file stream open until the MyObject object is disposed.

To dispose of the file stream as soon as the MyObject constructor has completed, I could instead write:

MyObject CreateMyObject(string path)
{
  using (FileStream stream = File.Open(path, FileMode.Open))
  {
    return new MyObject(stream);
  }
}

using (MyObject obj = CreateMyObject(path))
{
  // do something with obj
}

But I don't like the verbosity of this solution. I tried replacing CreateMyObject() with a lambda but I failed to find a legal syntax. Is there a way to do this without calling a custom creator function?

Edit: Bearing in mind some of the comments, I should point out that I'm trying to avoid try...finally - kind of the main reason for a using block in the first place.

Additional clarification: The MyObject object is constructed from information in the stream - i.e. its constructor reads the content of the stream in its entirity. No other method in MyObject references the stream. The content of the stream could come from anywhere - a file, a resource, an Internet socket, etc.

you dont need a using block at all, you could just create the stream, pass to MyObject, then call stream.Dispose(). Or course, you'll need to wrap this in a try catch — Eamonn McEvoy
– Eamonn McEvoy, Commented Jul 5, 2018 at 14:08
What would be the point of writing it like that? Why do you only need the stream in the constructor? — Patrick Hofman
– Patrick Hofman, Commented Jul 5, 2018 at 14:08
You're aware that obj = ...; using (obj) { .. } is a thing, right? You are not required to initialize the variable and wrap it in one single block. If you're concerned about obj possibly not being disposed when an exception occurs, just use try .. finally yourself instead of using. — Jeroen Mostert
– Jeroen Mostert, Commented Jul 5, 2018 at 14:08
If you don't need the stream for the whole time, why it needs to be passed as constructor argument? Maybe the constructor should not take the stream but what you want to read with it. Or it could at take the file-path and create and use it there. Is MyObject supposed to be the reader-class or just the class that holds the informations which you want to read? It should not be used for both because that are two separate concerns. — Tim Schmelter
– Tim Schmelter, Commented Jul 5, 2018 at 14:12

Robert Giesecke · Accepted Answer · 2018-07-06 08:49:24Z

1

You could invoke some magic like so:

TResult CreateUsingDisposable<TDisposable, TResult>(TDisposable disposable, Func<TDisposable, TResult> getResult)
  where TDisposable : IDisposable
{
  using (disposable)
  {
    return getResult(disposable);
  }
}

using (var obj = CreateUsingDisposable(new FileStream(path, FileMode.Open), stream => new MyObject(stream)))
{
}

But why? There's a super easy to read no-nonsense way of doing that:

  MyObject obj;
  using (var stream = new FileStream(path, FileMode.Open))
  {
    obj = new MyObject(stream);
  }
  using (obj)
  {

  }

edited Jul 6, 2018 at 8:49

answered Jul 5, 2018 at 14:14

Robert Giesecke

4,31424 silver badges22 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

maccettura Over a year ago

Wouldnt the stream be disposed by the time you get to using(obj)?

Ian Goldby Over a year ago

@maccettura That's the point. You want the stream closed as soon as the MyObject constructor has completed.

Ian Goldby Over a year ago

Forget the 'magic'. The second bit of code is exactly what I was flailing so hopelessly around for. Thanks. (Can I suggest you edit the 1st solution out of your answer?)

user585968 Over a year ago

@IanGoldby I don’t think he should. He’s making a very good point that the best way is the more readable way. The other solutions here and elsewhere on this page are arguably nothing more than an excercise in cleverness at the expense of readability

Ian Goldby Over a year ago

@MickyD You mean keep the 'clever' but less clear solution as a counterpoint to the no-nonsense good solution? Not sure I agree - a clear and simple solution stands on its own merit.

|

Titian Cernicova-Dragomir · Accepted Answer · 2018-07-05 14:10:36Z

1

While I don't see a way to avoid the creator function, you can make it generic enough to define once and use for any class:

static T WithStream<T>(string path, Func<FileStream, T> getter)
{
  using (FileStream stream = File.Open(path, FileMode.Open))
  {
    return getter(stream);
  }
}

class MyObject : IDisposable
{
    public MyObject (Stream stream){ /* Work with stream */}
    public void Dispose(){}

}
static void Main()
{

    using (MyObject obj = WithStream("path", fs => new MyObject(fs)))
    {
      // do something with obj
    }
}

answered Jul 5, 2018 at 14:10

Titian Cernicova-Dragomir

253k37 gold badges465 silver badges395 bronze badges

Collectives™ on Stack Overflow

Avoiding nested using blocks when outer is used only to construct inner

2 Answers 2

6 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

6 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related