finallyブロックが例外をスローするとどうなりますか？
Finallyブロックが例外をスローした場合、exactlyはどうなりますか？
具体的には、finallyブロックの途中で例外がスローされるとどうなりますか。このブロックの残りのステートメント（後）は呼び出されますか？
例外が上方に伝播することを認識しています。
Finallyブロックが例外をスローした場合、exactlyはどうなりますか？
その例外は外に伝播し、より高いレベルで処理されます（できます）。
Finallyブロックは、例外がスローされるポイントを超えて完了しますnotです。
以前の例外の処理中にfinallyブロックが実行されていた場合、その最初の例外は失われます。
C＃4言語仕様§8.9.5：finallyブロックが別の例外をスローすると、現在の例外の処理は終了します。
このような質問については、通常、Visual Studioで空のコンソールアプリケーションプロジェクトを開き、小さなサンプルプログラムを作成します。
using System;
class Program
{
static void Main(string[] args)
{
try
{
try
{
throw new Exception("exception thrown from try block");
}
catch (Exception ex)
{
Console.WriteLine("Inner catch block handling {0}.", ex.Message);
throw;
}
finally
{
Console.WriteLine("Inner finally block");
throw new Exception("exception thrown from finally block");
Console.WriteLine("This line is never reached");
}
}
catch (Exception ex)
{
Console.WriteLine("Outer catch block handling {0}.", ex.Message);
}
finally
{
Console.WriteLine("Outer finally block");
}
}
}
プログラムを実行すると、catchおよびfinallyブロックが実行される正確な順序が表示されます。例外がスローされた後のfinallyブロックのコードは実行されないことに注意してください（実際、このサンプルプログラムでは、Visual Studioは到達不能コードを検出したことを警告します）。
tryブロックからスローされた内部catchブロック処理例外。 Inner finally block finallyブロックからスローされた外部catchブロック処理例外。 Outer finally block
追加コメント
Michael Damatovが指摘したように、（内部）tryブロックで処理しない場合、catchブロックからの例外は「食べられ」ます。実際、上記の例では、再スローされた例外は外側のcatchブロックに表示されません。それをさらに明確にするために、次のわずかに変更されたサンプルを見てください。
using System;
class Program
{
static void Main(string[] args)
{
try
{
try
{
throw new Exception("exception thrown from try block");
}
finally
{
Console.WriteLine("Inner finally block");
throw new Exception("exception thrown from finally block");
Console.WriteLine("This line is never reached");
}
}
catch (Exception ex)
{
Console.WriteLine("Outer catch block handling {0}.", ex.Message);
}
finally
{
Console.WriteLine("Outer finally block");
}
}
}
出力からわかるように、内部例外は「失われました」（つまり無視されます）：
Inner finally block Finalブロックからスローされた外部キャッチブロック処理例外。 Outer finallyブロック
保留中の例外がある場合（tryブロックにfinallyがあるがcatchがない場合）、新しい例外がその例外を置き換えます。
保留中の例外がない場合、finallyブロックの外で例外をスローするのと同じように機能します。
例外が伝播されます。
元の例外がより重要な場合に備えて、「元の例外」（tryブロックでスロー）を保存し、「最終的な例外」（finallyブロックでスロー）を犠牲にするための迅速な（かなり明白な）スニペット：
try
{
throw new Exception("Original Exception");
}
finally
{
try
{
throw new Exception("Finally Exception");
}
catch
{ }
}
上記のコードが実行されると、「元の例外」が呼び出しスタックを伝播し、「最終的に例外」が失われます。
例外のために開かれなかったストリームを閉じようとしてエラーをキャッチするためにこれをしなければなりませんでした。
errorMessage = string.Empty;
try
{
byte[] requestBytes = System.Text.Encoding.ASCII.GetBytes(xmlFileContent);
webRequest = WebRequest.Create(url);
webRequest.Method = "POST";
webRequest.ContentType = "text/xml;charset=utf-8";
webRequest.ContentLength = requestBytes.Length;
//send the request
using (var sw = webRequest.GetRequestStream())
{
sw.Write(requestBytes, 0, requestBytes.Length);
}
//get the response
webResponse = webRequest.GetResponse();
using (var sr = new StreamReader(webResponse.GetResponseStream()))
{
returnVal = sr.ReadToEnd();
sr.Close();
}
}
catch (Exception ex)
{
errorMessage = ex.ToString();
}
finally
{
try
{
if (webRequest.GetRequestStream() != null)
webRequest.GetRequestStream().Close();
if (webResponse.GetResponseStream() != null)
webResponse.GetResponseStream().Close();
}
catch (Exception exw)
{
errorMessage = exw.ToString();
}
}
webRequestは作成されたが、接続中に接続エラーが発生した場合
using (var sw = webRequest.GetRequestStream())
次に、webRequestが作成されたために開いていると考えられていた接続を閉じようとして、最終的に例外をキャッチします。
最終的に内部にtry-catchがなかった場合、このコードはwebRequestのクリーンアップ中に未処理の例外を引き起こします
if (webRequest.GetRequestStream() != null)
そこから、発生したエラーを適切に処理せずにコードが終了し、呼び出しメソッドに問題が発生します。
これが例として役立つことを願っています
public void MyMethod()
{
try
{
}
catch{}
finally
{
CodeA
}
CodeB
}
CodeAとCodeBによってスローされる例外の処理方法は同じです。
finallyブロックでスローされる例外には特別なものはありません。コードBによる例外スローとして扱われます。
別の例外がアクティブなときに例外をスローすると、最初の例外が2番目の（後の）例外に置き換えられます。
何が起こるかを示すいくつかのコードは次のとおりです。
public static void Main(string[] args)
{
try
{
try
{
throw new Exception("first exception");
}
finally
{
//try
{
throw new Exception("second exception");
}
//catch (Exception)
{
//throw;
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
- コードを実行すると、「2番目の例外」が表示されます
- Tryおよびcatchステートメントのコメントを外すと、「最初の例外」が表示されます
- また、スローのコメントを外します。ステートメントを実行すると、再び「2番目の例外」が表示されます。
例外は伝播し、より高いレベルで処理する必要があります。例外がより高いレベルで処理されない場合、アプリケーションはクラッシュします。 「最終」ブロックの実行は、例外がスローされた時点で停止します。
例外があるかどうかに関係なく、「最終」ブロックの実行が保証されます。
Tryブロックで例外が発生した後に「finally」ブロックが実行されている場合、
そして、その例外が処理されない場合
そして、finallyブロックが例外をスローする場合
その後、tryブロックで発生した元の例外は失われます。
public class Exception
{
public static void Main()
{
try
{
SomeMethod();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static void SomeMethod()
{
try
{
// This exception will be lost
throw new Exception("Exception in try block");
}
finally
{
throw new Exception("Exception in finally block");
}
}
}
数ヶ月前、私もこのようなことに直面しました、
private void RaiseException(String errorMessage)
{
throw new Exception(errorMessage);
}
private void DoTaskForFinally()
{
RaiseException("Error for finally");
}
private void DoTaskForCatch()
{
RaiseException("Error for catch");
}
private void DoTaskForTry()
{
RaiseException("Error for try");
}
try
{
/*lacks the exception*/
DoTaskForTry();
}
catch (Exception exception)
{
/*lacks the exception*/
DoTaskForCatch();
}
finally
{
/*the result exception*/
DoTaskForFinally();
}
このような問題を解決するために、次のようなユーティリティクラスを作成しました。
class ProcessHandler : Exception
{
private enum ProcessType
{
Try,
Catch,
Finally,
}
private Boolean _hasException;
private Boolean _hasTryException;
private Boolean _hasCatchException;
private Boolean _hasFinnallyException;
public Boolean HasException { get { return _hasException; } }
public Boolean HasTryException { get { return _hasTryException; } }
public Boolean HasCatchException { get { return _hasCatchException; } }
public Boolean HasFinnallyException { get { return _hasFinnallyException; } }
public Dictionary<String, Exception> Exceptions { get; private set; }
public readonly Action TryAction;
public readonly Action CatchAction;
public readonly Action FinallyAction;
public ProcessHandler(Action tryAction = null, Action catchAction = null, Action finallyAction = null)
{
TryAction = tryAction;
CatchAction = catchAction;
FinallyAction = finallyAction;
_hasException = false;
_hasTryException = false;
_hasCatchException = false;
_hasFinnallyException = false;
Exceptions = new Dictionary<string, Exception>();
}
private void Invoke(Action action, ref Boolean isError, ProcessType processType)
{
try
{
action.Invoke();
}
catch (Exception exception)
{
_hasException = true;
isError = true;
Exceptions.Add(processType.ToString(), exception);
}
}
private void InvokeTryAction()
{
if (TryAction == null)
{
return;
}
Invoke(TryAction, ref _hasTryException, ProcessType.Try);
}
private void InvokeCatchAction()
{
if (CatchAction == null)
{
return;
}
Invoke(TryAction, ref _hasCatchException, ProcessType.Catch);
}
private void InvokeFinallyAction()
{
if (FinallyAction == null)
{
return;
}
Invoke(TryAction, ref _hasFinnallyException, ProcessType.Finally);
}
public void InvokeActions()
{
InvokeTryAction();
if (HasTryException)
{
InvokeCatchAction();
}
InvokeFinallyAction();
if (HasException)
{
throw this;
}
}
}
そして、このように使用
try
{
ProcessHandler handler = new ProcessHandler(DoTaskForTry, DoTaskForCatch, DoTaskForFinally);
handler.InvokeActions();
}
catch (Exception exception)
{
var processError = exception as ProcessHandler;
/*this exception contains all exceptions*/
throw new Exception("Error to Process Actions", exception);
}
ただし、パラメータを使用して型を返す場合は別の話です