使用{}语句在内部调用 return 是一种好方法吗？

我只是想知道在 using块中调用 return是否安全/好。

为了前任。

using(var scope = new TransactionScope())
{
// my core logic
return true; // if condition met else
return false;
scope.Complete();
}

我们知道最后一个花括号 dispose()会被取消。但是在上面的情况下，由于 return跳出了给定范围(AFAIK)的控制..。

  1. 我的 scope.Complete()接到电话了吗？
  2. 范围的 dispose()方法也是如此。
42969 次浏览
小开
最佳答案

It's perfectly safe to call return inside your using block, since a using block is just a try/finally block.

In your example above after return true, the scope will get disposed and the value returned. return false, and scope.Complete() will not get called. Dispose however will be called regardless since it reside inside the finally block.

Your code is essentially the same as this (if that makes it easier to understand):

var scope = new TransactionScope())
try
{
// my core logic
return true; // if condition met else
return false;
scope.Complete();
}
finally
{
if( scope != null)
((IDisposable)scope).Dispose();
}

Please be aware that your transaction will never commit as there's no way to get to scope.Complete() to commit the transaction.

小开

That's fine - finally clauses (which is what the closing curly brace of the using clause does under the hood) always get executed when the scope is left, no matter how.

However, this is only true for statements that are in the finally block (which cannot be explicitly set when using using). Therefore, in your example, scope.Complete() would never get called (I expect the compiler to warn you about unreachable code though).

小开

In general, it is a good approach. But in your case, if you return before calling the scope.Complete(), it will just trash the TransactionScope. Depends to your design.

So, in this sample, Complete() is not called, and scope is disposed, assuming it is inheriting IDisposable interface.

小开

In this example, scope.Complete() will never execute. However, the return command will cleanup everything that is assigned on the stack. The GC will take care of everything that is unreferenced. So, unless there is an object that can not be picked up by the GC, there is no problem.

小开

scope.Complete should definitely be called before return. Compiler will display a warning and this code will never be called.

Regarding return itself - yes, it is safe to call it inside using statement. Using is translated to try-finally block behind the scene and finally block is to be certainly executed.

小开

In the example you have provided, there is a problem; scope.Complete() is never called. Secondly, it is not a good practice to use return statement inside using statements. Refer to the following:

using(var scope = new TransactionScope())
{
//have some logic here
return scope;
}

In this simple example, the point is that; the value of scope will be null when using statement is finished.

So it is better not to return inside using statements.


提交答案