一个 using 块，在构造函数中有一个 object 初始化块

Question

If you call a constructor from a within a using statement the object is automatically disposed is wrapped it with a try/catch block. That is an object initializer block in the constructor.

But what becomes with member types that are initialized in the same statement? eg:

  class TypeThatThrowsAnException 
  {
       public TypeThatThrowsAnException() 
       {
           throw new Exception();
       }
  }

  using (SomeDisposable ds = new SomeDisposable() {
       MemberThatThrowsAnException m = new TypeThatThrowsAnException()
  })
  {
       // inside using statement
       ds.doSomething();
  }

What happens with MemberThatThrowsAnException when it throws an exception when SomeDisposable is initialized, ie, the code block is executed?

And does it make any difference if we call those members constructors outside the scope of the using block?

  class TypeThatThrowsAnException 
  {
       public TypeThatThrowsAnException() 
       {
           throw new Exception();
       }
  }

  class SomeClass 
  {
       public static TypeThatThrowsAnException StaticMember 
       {
          get
          {
               return new TypeThatThrowsAnException();
          }
       }
  } 

  using (SomeDisposable ds = new SomeDisposable() {
       MemberThatThrowsAnException = SomeClass.StaticMember
  })
  {
       // inside using statement
       ds.doSomething();
  }

In some scenarios this can be pretty nice and readable, but I would like to know if thare are any caveats or pitfalls in this way. Or that it is a no-go all the way . Besides that you need to keep the readability in mind.

Answer 1

Object initializers are in some sense a red herring here... but they're one example of where a problem is avoidable.

The object isn't "guarded" by the using statement until the resource acquisition expression has completed normally. In other words, your code is like this:

SomeDisposable tmp = new SomeDisposable();
tmp.MemberThatThrowsAnException = new TypeThatThrowsAnException();

using (SomeDisposable ds = tmp)
{
    // Stuff
}

That's more obviously problematic:)

Of course the solution is to assign the property inside the using statement:

using (SomeDisposable ds = new SomeDisposable())
{
    MemberThatThrowsAnException = new TypeThatThrowsAnException();
    // Stuff
}

Now we're only relying on the constructor of SomeDisposable to clean up after itself if it ends up throwing an exception - and that's a more reasonable requirement.

Answer 2

From what I can see, your SomeDisposable class has a property of type TypeThatThrowsAnException, that you're initializing as you instantiate the SomeDisposable - yes?

using () ie the Dispose pattern is a short-hand that actually emits this: -

SomeDisposable ds = null;

try
{
    ds = new SomeDisposable();
}
finally
{
    if (ds != null)
        ds.Dispose();
}

So if the constructor for your type throws an exception, control will immediately pass to the finally block.

Answer 3

Find this post on Ayende's blog on the subject. It's about object initializers in using statements but it seems somehow related to your question.