捕获Using块的目标对象的构造函数中抛出的异常

Question

using(SomeClass x = new SomeClass("c:/temp/test.txt"))
{
...
}

在 using 块内，一切正常，可以正常处理异常。但是如果 SomeClass 的构造函数可以抛出异常怎么办？

Answer 1

将您的使用放入 try catch fe

try
{
   using(SomeClass x = new SomeClass("c:/temp/test.txt"))
   {
       ...
   }
}
catch(Exception ex)
{
   ...
}

Answer 2

是的，当构造函数抛出异常时，这就会出现问题。 您所能做的就是将 using 块包装在 try/catch 块中。 这就是为什么您必须这样做。

using 块只是语法糖，编译器将每个 using 块替换为等效的 try/finally 块。唯一的问题是编译器不会将构造函数包装在 try 块中。编译后的代码将在 IL 中进行以下转换。

        //Declare object x of type SomeClass.
        SomeClass x;

        //Instantiate the object by calling the constructor.
        x = new SomeClass("c:/temp/test.txt");

        try
        {
            //Do some work on x.
        }
        finally
        {
            if(x != null)
                x.Dispose();
        }

从代码中可以看出，如果构造函数抛出异常，则对象 x 将不会被实例化，并且如果不处理，控件将不会从异常引发点进一步移动。

我刚刚发布了 昨晚在我的博客上发表了关于此主题的博客文章。

我现在想知道为什么使用 C#
设计者没有包裹对象
try 块内的构造
根据我的说法，这应该是
完成。

编辑

我想我找到了为什么 C# 不将对象构造包装到生成的 try 块中来代替 using 块的答案。

原因很简单。如果将声明和实例化都包装在 try 块中，则该对象将超出后续的 finally 块的范围，并且代码将无法编译，因为对于 finally 块，该对象几乎不存在。如果您仅将构造包装在 try 块中并在 try 块之前保留声明，即使在这种情况下，它也不会编译，因为它发现您正在尝试使用分配的变量。

Answer 3

我编写了一个快速测试程序来检查这一点，当构造函数中抛出异常时，Dispose 方法似乎不会被调用；

class Program
{
    static void Main(string[] args)
    {
        try
        {
            using (OtherClass inner = new OtherClass())
            {
                Console.WriteLine("Everything is fine");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        Console.Read();
    }
}

class OtherClass : IDisposable
{
    public OtherClass()
    {
        throw new Exception("Some Error!");
    }

    void IDisposable.Dispose()
    {
        Console.WriteLine("I've disposed my resources");
    }
}

输出 ：

出现一些错误！

如果你不抛出异常..

输出：

一切都很好

我已经处置了我的资源

大概这是因为该对象从未创建，所以没有什么可以调用 Dispose 的。

我不确定如果构造函数已经分配了一些通常需要通过 Dispose 进行适当清理的资源，但随后发生了异常，会发生什么。

Answer 4

对于一个设计良好的类来说这不应该是一个问题。请记住总体问题：

public class HoldsResources : IDisposable
{
    public HoldsResources()
    {
        // Maybe grab some resources here
        throw new Exception("whoops");
    }
}

using (HoldsResources hr = new HoldsResources())
{
}

因此，问题是，在抛出异常之前，您应该如何处理 HoldsResources 构造函数分配的资源？

答案是，您不应该对这些资源做任何事情。那不是你的工作。当决定 HoldsResources 将持有资源时，就产生了正确处置资源的义务。这意味着构造函数中的 try/catch/finally 块，并且意味着正确实现 IDisposable 来在 Dispose 方法中处置这些资源。

您的责任是在使用完实例后使用using块调用他的Dispose方法。没有别的了。

Answer 5

当您在 ctor 中获得了不受垃圾回收影响的资源时，您必须确保在出现问题时处置它们。

此示例显示了一个在出现问题时可以防止泄漏的 ctor，当您在工厂方法内分配一次性资源时，也适用相同的规则。

class Sample
{
  IDisposable DisposableField;

  ...

  public Sample()
  {
    var disposable = new SomeDisposableClass();
    try
    {
       DoSomething(disposable);
       DisposableField = disposable;
    }
    catch
    {
       // you have to dispose of it yourself, because
       // the exception will prevent your method/ctor from returning to the caller.
       disposable.Dispose();
       throw;
    }
  }
}

编辑：我不得不将我的样本从工厂更改为演员，因为显然它并不像我希望的那么容易理解。 （从评论来看。）

当然原因是：当你调用一个工厂或一个ctor时，你只能处理它的结果。当电话接通时，您必须假设到目前为止一切正常。

当给演员或工厂打电话时，你不必做任何逆向精神分析来处理任何你无论如何也拿不到的东西。如果它确实抛出异常，则工厂/ctor有责任在重新抛出异常之前清除所有半分配的内容。
（希望这一次足够详细......）