在 C# 中对同一作用域使用多个 using 语句时，是否可以保证调用 Dispose() 方法的顺序？

Question

using (Stuff1 stf1 = new Stuff1(...)) // Allocation of stf1
using (Stuff2 stf2 = new Stuff2(...)) // Allocation of stf2
{
    try
    {
        // ... do stuff with stf1 and stf2 here ...
    }
    catch (Stuff1Exception ex1)
    {
        // ...
    }
    catch (Stuff2Exception ex2)
    {
        // ...
    }
} // Automatic deterministic destruction through Dispose() for stf1/stf2 - but in which order?

换句话说，是否保证首先调用 stf2 的 Dispose() 方法，然后保证其次调用 stf1 的 Dispose() 方法？ （基本上：Dispose() 方法是按照与其所属对象的分配相反的顺序调用的？）

Answer 1

using 语句与其他块级语句没有什么不同。如果您编写这样的代码：

if (...)
    if (...)
    {

    }

您会很清楚事情发生的顺序（并不是我会推荐该特定结构），因为它与此完全相同：

if (...)
{
    if(...)
    {

    }
}

所以它是使用using。您的代码与以下代码没有什么不同：

using (...)
{
    using(...)
    {

    }
}

在这里，很明显内部 using 块首先终止，因此应该首先释放它的资源。

Answer 2

是的，首先调用 stf2.Dispose，然后调用 stf1.Dispose

Answer 3

无论如何，using 语句都会转换为 try-finally 。它只是语法糖..所以你是正确的，你的例子在编译时将被翻译如下：

try
{
    Stuff1 stf1 = new Stuff1());
    try
    {
        Stuff2 stf2 = new Stuff2();
    }
    finally
    {
        stf2.Dispose();
    }
}
finally
{
    stf1.Dispose();
}

Answer 4

Stuff2 将在 Stuff1 之前被处理，因为它位于内部块中。

即使您没有在 Stuff1 的外部块上使用大括号，它仍然与您使用大括号时一样。

Answer 5

由于可能重新订购，不提供任何保证。在结束卷曲（或您的示例中的隐式卷曲）上调用 Dispose。您将始终在非优化的调试版本中看到预期的顺序。您可以使用 Thread.MemoryBarrier 来强制操作顺序。

using (Stuff1 stf1 = new Stuff1(...)) // Allocation of stf1
using (Stuff2 stf2 = new Stuff2(...)) // Allocation of stf2
{ {
    try
    {
        // ... do stuff with stf1 and stf2 here ...
    }
    catch (Stuff1Exception ex1)
    {
        // ...
    }
    catch (Stuff2Exception ex2)
    {
        // ...
    }
} Thread.MemoryBarrier(); }

释放模式优化的方式是保证在所有指令完成后该线程上的结果可预测。其他一切（从单独核心上的不同线程查看）都可供争夺。从另一个线程观察到，stf2 尚未释放但 stf1 已释放的情况并不违反规则。除非你强制执行操作顺序。尝试编写一些断言并在 Jinx 下运行

Answer 6

是的，Dispose 方法将在 using 作用域结束时被调用，因此 Dispose() 方法的调用顺序与其所属对象的分配顺序相反