try {return x;}最后{x = null;}声明吗?

我在另一个问题中看到了这个技巧，想知道是否有人能向我解释一下这到底是如何工作的?

try { return x; } finally { x = null; }

我的意思是，finally子句真的执行后 return语句吗?这段代码是如何线程不安全的?你能想到任何其他的黑客，可以做w.r.t.这个try-finally黑客?

86193 次浏览
小开

finally子句在return语句之后执行，但在实际从函数返回之前执行。我认为这与线程安全没有什么关系。这不是一个hack - finally保证总是运行，无论你在try块或catch块中做什么。

小开
最佳答案

不可以——在IL级别，您不能从异常处理的块内部返回。它将数据存储在一个变量中，然后返回

即类似于:

int tmp;
try {
tmp = ...
} finally {
...
}
return tmp;

例如(使用反射器):

static int Test() {
try {
return SomeNumber();
} finally {
Foo();
}
}

编译:

.method private hidebysig static int32 Test() cil managed
{
.maxstack 1
.locals init (
[0] int32 CS$1$0000)
L_0000: call int32 Program::SomeNumber()
L_0005: stloc.0
L_0006: leave.s L_000e
L_0008: call void Program::Foo()
L_000d: endfinally
L_000e: ldloc.0
L_000f: ret
.try L_0000 to L_0008 finally handler L_0008 to L_000e
}

这基本上声明了一个局部变量(CS$1$0000)，将值放入变量中(在已处理的块中)，然后在退出块后加载变量，然后返回它。反射器将其渲染为:

private static int Test()
{
int CS$1$0000;
try
{
CS$1$0000 = SomeNumber();
}
finally
{
Foo();
}
return CS$1$0000;
}
小开

如果x是一个局部变量，我看不出这一点，因为x无论如何都会在方法退出时被有效地设置为空，并且返回值的值不为空(因为它在调用x设置为空之前被放置在寄存器中)。

我只能看到这样做，如果你想要保证一个字段的值在返回时(和返回值确定之后)的变化。

小开

finally语句被执行，但返回值不受影响。执行顺序为:

  1. 执行return语句之前的代码
  2. return语句中的表达式被求值
  3. 最后执行block
  4. 返回步骤2中计算的结果

下面是一个简短的程序来演示:

using System;


class Test
{
static string x;


static void Main()
{
Console.WriteLine(Method());
Console.WriteLine(x);
}


static string Method()
{
try
{
x = "try";
return x;
}
finally
{
x = "finally";
}
}
}

这将打印“try”(因为这是返回的结果)，然后打印“finally”，因为这是x的新值。

当然，如果我们返回一个对可变对象的引用(例如StringBuilder)，那么在finally块中对对象所做的任何更改在返回时都是可见的——这并不影响返回值本身(它只是一个引用)。

小开

在Marc Gravell和Jon Skeet给出的答案之外，重要的是要注意对象和其他引用类型在返回时的行为相似，但确实有一些不同。

返回的“What”遵循与简单类型相同的逻辑:

class Test {
public static Exception AnException() {
Exception ex = new Exception("Me");
try {
return ex;
} finally {
// Reference unchanged, Local variable changed
ex = new Exception("Not Me");
}
}
}

在finally块中为局部变量分配新引用之前，已经计算了返回的引用。

执行的本质是:

class Test {
public static Exception AnException() {
Exception ex = new Exception("Me");
Exception CS$1$0000 = null;
try {
CS$1$0000 = ex;
} finally {
// Reference unchanged, Local variable changed
ex = new Exception("Not Me");
}
return CS$1$0000;
}
}

不同的是，仍然可以使用对象的属性/方法修改可变类型，如果你不小心，可能会导致意想不到的行为。

class Test2 {
public static System.IO.MemoryStream BadStream(byte[] buffer) {
System.IO.MemoryStream ms = new System.IO.MemoryStream(buffer);
try {
return ms;
} finally {
// Reference unchanged, Referenced Object changed
ms.Dispose();
}
}
}

关于try-return-finally要考虑的第二件事是，“通过引用”传递的参数在返回后仍然可以修改。只有返回值被求值并存储在一个等待返回的临时变量中，其他变量仍然按正常方式修改。out参数的契约甚至可以直到finally以这种方式阻塞才被实现。

class ByRefTests {
public static int One(out int i) {
try {
i = 1;
return i;
} finally {
// Return value unchanged, Store new value referenced variable
i = 1000;
}
}


public static int Two(ref int i) {
try {
i = 2;
return i;
} finally {
// Return value unchanged, Store new value referenced variable
i = 2000;
}
}


public static int Three(out int i) {
try {
return 3;
} finally {
// This is not a compile error!
// Return value unchanged, Store new value referenced variable
i = 3000;
}
}
}

像任何其他流结构一样，“try-return-finally”也有它的位置，并且可以让代码看起来比编写实际上编译到的结构更干净。但必须小心使用，以避免受到伤害。


提交答案