标签: try-finally

public void testFinally(){
System.out.println(setOne().toString());

}

protected StringBuilder setOne(){
StringBuilder builder=new StringBuilder();
try{
builder.append("Cool");
return builder.append("Return");
}finally{
builder=null; /* ;) */
}
}

为什么输出是CoolReturn,而不是null？

此致,
Mahendra Athneria

我现在已经看过这种模式了几次:

        bool success = false;
        try
        {
            DoSomething();
            success = true;
        }
        finally
        {
            if (!success)
                Rollback();
        }

而且我一直在想:为什么这比使用catch回滚更好？

        try
        {
            DoSomething();
        }
        catch
        {
            Rollback();
            throw;
        }

确保更改在失败时回滚的两种方法之间有什么区别？

假设我有以下例程:

function ReadFile(f : TFilename) : Boolean;
var
  fs : TFileStream;
begin
  Result := False;
  try
    fs := TFileStream.Create(f, ...);
    try
      // read file ...
      Result := True;
    finally
      FreeAndNil(fs);
    end;
  except
    // handle exceptions ...
  end;
end;

拥有except和finally转置有什么含义？我已经看到了很多与他们的职位左右逢源左右,但我还没有看到一个明确的解释这是适当的在哪些情况下(我仍然认为这是奇怪的是,在上述构建,该finally块执行后的except块!).

我也看过帖子表明混音try..except和try..finally积木并不是一个好主意.如果例程在正常操作中抛出异常(例如在某些Indy例程中),你怎么能避免它呢？

有没有办法模拟一种try-finally或try-except没有它们的语言？

如果有一些随机的,不可预测的异常发生,我需要确保一些清理运行.

我可以尝试确保抛出没有异常,这样我确信我的清理代码总是运行 - 但后来我不需要了try-finally/except.

就在这一刻,我正在努力创造一个try-finallyLua; 但我认为任何解决方案也适用于其他语言.

虽然,就我而言,我无法弄清楚如何在没有语言基础设施提供的管道的情况下处理异常.

但从来没有伤害过要求.

例如:

/**
 * Constructor
 */
public Test(InputStream in){
   try{
      this.inputStream = in;
   } finally{
      inputStream.close();
   }
}

在创建Test对象后,传递给教师的InputStream是否立即关闭？或者,当Test对象被销毁时它是否关闭？我不知道如何在C++中实现类似于析构函数的东西.

我对OO Delphi的最佳实践有一个普遍的疑问.目前,我将try-finally块放在我创建对象的任何地方,以便在使用后释放该对象(以避免内存泄漏).例如:

aObject := TObject.Create;
try
  aOBject.AProcedure();
  ...
finally
  aObject.Free;
end;

代替:

aObject := TObject.Create;
aObject.AProcedure();
..
aObject.Free;

你认为这是好的做法还是过多的开销？那表现怎么样？

查看Java虚拟机规范和编译代码,告诉我们如何在java中实现"synchronized"块.以下代码:

public void testSync()
{
    Object obj = getSomeObject();
    synchronized (obj) { doSomething(); }
}

...大致相当于这个伪代码:

public void testSync()
{
    Object obj = getSomeObject();
    Object __temp = obj;
    monitorenter __temp;
    try { doSomething(); }
    finally { monitorexit __temp; }
}

......有一个例外.

出于某种原因,异常表显示两个finally处理程序.例如:

  Exception table:
     from    to  target type
        12    20    23   any
        23    25    23   any

第一个处理程序是我期望的,但第二个处理程序实际上是第一个处理程序的finally块,如果它捕获异常,它会执行相同的处理程序.您可以通过以下方式将其可视化:

try { doSomething(); }
finally { beginTry: try { monitorexit __temp; } finally { goto beginTry; } }

有谁知道这是为什么？如果它只是finally块,则表中的第二个条目不会出现.此外,如果它已经被抛出异常,我看不出任何可能的理由想要再次执行finally块. …

如果尝试以下代码，则会看到未返回正常的块返回值，但最终的块返回值为：

>>> def f():
...     try:
...         return "normal"
...     finally:
...         return "finally"
... 
>>> f()
'finally'

一个更高级的示例是在每个return语句中调用一个函数：

在这种情况下，我可以看到：

• 在普通块中，对show函数进行求值（但不返回），
• 在finally块中，对show函数进行求值并返回：

>>> def show(x):
...     print(x)
...     return x
... 
>>> def g():
...     try:
...         return show("normal")
...     finally:
...         return show("finally")
... 
>>> g()
normal
finally
'finally'

在finally子句中有return语句是一种好习惯吗？还是它是一个潜在的错误（应通过代码分析工具或代码审查来检测）？

编辑

另一个有例外的示例：

>>> def f():
...     try:
...         raise ValueError("bad")
...     finally:
...         return "good"
... 
>>> f()
'good'

奇怪的！

我发现了一个没有调用finally块的情况.

要点:

using System;
using System.Collections.Generic;
using System.Threading;
using System.ComponentModel;

    class MainClass{
        static IEnumerable<int> SomeYieldingMethod(){
            try{
                yield return 1;
                yield return 2;
                yield return 3;
            }finally{
                Console.WriteLine("Finally block!");
            }
        }

        static void Main(){
            Example(7);
            Example(2);
            Example(3);
            Example(4);
        }

        static void Example(int iterations){
            Console.WriteLine("\n Example with {0} iterations.", iterations);
            var e = SomeYieldingMethod().GetEnumerator();
            for (int i = 0; i< iterations; ++i) {
                Console.WriteLine(e.Current);
                e.MoveNext();
            }
        }
    }

结果如下:

Example with 7 iterations.
0
1
2
3
Finally block!
3
3
3 …

空try值具有某些价值，如其他地方所述

try{}
finally
{ 
   ..some code here
}

但是，最后有什么用为空：

try
{
   ...some code here
}
finally
{}

编辑：注意我还没有实际检查以查看CLR是否为空生成任何代码 finally{}