0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

async Taskなのに例外を捕まえられない?|awaitし忘れとtry-catchの落とし穴

0
Posted at

はじめに

前回の記事では、async voidを避けた方がいい理由について説明しました。

async voidは、呼び出し元が処理の完了を待てず、例外も扱いにくいという問題があります。

そこで、非同期メソッドの戻り値をTaskに変更します。

private async Task LoadDataAsync()
{
    await Task.Delay(1000);

    throw new Exception("読み込みエラー");
}

これで、呼び出し元から処理の完了や失敗を確認できるようになります。

ところが、async Taskに変更しただけでは、例外をうまく捕まえられない場合があります。

「async voidをやめてasync Taskにしたのに、どうして?」

今回は、Taskとawait、そしてtry-catchの関係を整理してみます。


1. try-catchを書いたのに例外が捕まらない?

まずは、次のコードを見てください。

private async Task LoadDataAsync()
{
    await Task.Delay(1000);

    throw new Exception("読み込みエラー");
}

private void StartLoad()
{
    try
    {
        Task task = LoadDataAsync();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

LoadDataAsync()では、1秒後に例外が発生します。

そして、呼び出し元にはtry-catchがあります。

一見すると、例外を捕まえられそうですよね。

しかし、このコードでは、LoadDataAsync()内で発生した例外を呼び出し元のcatchで捕まえることはできません。

なぜでしょうか。

ポイントは、Taskを受け取っているだけで、awaitしていないことです。

※この例では、問題を分かりやすくするためにTaskを変数に代入しています。実際の開発では、使用していないTaskについて警告や静的解析の指摘を受ける場合があります。


2. async Taskの例外はどこへ行く?

ここで重要なのが、Taskの役割です。

async Taskメソッドを呼び出すと、呼び出し元にはTaskが返されます。

Taskは、非同期処理の完了や失敗を表すものです。

例えば、

Task task = LoadDataAsync();

この時点では、LoadDataAsync()の処理が完了しているとは限りません。

呼び出し元は、処理の完了を待たずに先へ進むことができます。

では、非同期処理の途中で例外が発生した場合はどうなるのでしょうか。

async Taskメソッド内で処理されなかった例外は、返されたTaskに記録されます。

そのTaskは、失敗した状態になります。

つまり、非同期メソッドを呼び出しただけでは、内部で発生した例外が呼び出し元のcatchに直接渡されるわけではないのです。

先ほどのコードでは、Taskを受け取った後、その結果を確認していません。

そのため、呼び出し元のcatchでは例外を捕まえられないのです。


3. awaitすると例外を捕まえられる

では、どうすればいいのでしょうか。

答えは、awaitを使うことです。

private async Task StartLoadAsync()
{
    try
    {
        await LoadDataAsync();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

今度は、LoadDataAsync()の呼び出しにawaitを付けました。

これで、LoadDataAsync()内で発生した例外をcatchで捕まえられます。

なぜでしょうか。

awaitは、対象のTaskが完了するまで、その後の処理の実行を保留します。

ただし、スレッドを占有して待ち続けるわけではありません。

Taskがまだ完了していない場合は、呼び出し元に制御を戻し、完了後に続きの処理を再開します。

そして、待機していたTaskが例外によって失敗していた場合、awaitした場所で、その例外が再び投げられます。

そのため、awaitをtry-catchの中に書けば、例外を捕まえることができるのです。

ここで覚えておきたいのは、

Taskは処理の完了や失敗を表し、awaitはその結果を受け取る

という関係です。


4. try-catchはどこに書けばいい?

次のコードを見てください。

private async Task StartLoadAsync()
{
    Task task = LoadDataAsync();

    try
    {
        await task;
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

これは、LoadDataAsync()内の例外を捕まえられるコードです。

Taskを取得する場所と、awaitする場所が分かれていますが、例外はawaitした場所で捕まえられます。

では、次のコードはどうでしょうか。

private async Task StartLoadAsync()
{
    Task task;

    try
    {
        task = LoadDataAsync();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
        return;
    }

    await task;
}

この場合、LoadDataAsync()内で発生した例外は、最初のcatchでは捕まえられません。

例外そのものはLoadDataAsync()の内部で発生しています。

しかし、呼び出し元にその例外が伝わるのは、後ろにあるawait taskの場所です。

そのawaitがtry-catchの外にあるため、最初のcatchでは捕まえられないのです。

つまり、try-catchで囲むべきなのは、非同期メソッドの呼び出しだけではなく、例外を受け取るawaitの部分ということになります。

なお、ここで説明しているのはasync Taskメソッド内部で発生した例外です。

通常のTaskを返すメソッドが、Taskを返す前に同期的に例外を投げるケースとは区別して考える必要があります。


5. 実務では何が困る?|保存に失敗したのに成功表示

ここまで、Taskと例外処理の関係を説明してきました。

では、awaitし忘れると、実際のアプリケーションではどのような問題が起こるのでしょうか。

例えば、WPFの画面に保存ボタンがあるとします。

次のコードを見てください。

private async Task SaveDataAsync()
{
    await Task.Delay(1000);

    throw new Exception("保存に失敗しました");
}

private void SaveButton_Click(
    object sender,
    RoutedEventArgs e)
{
    _ = SaveDataAsync();

    MessageBox.Show("保存しました");
}

SaveDataAsync()は、保存処理を想定したメソッドです。

この例では、1秒後に例外が発生するようにしています。

しかし、ボタンを押すと、保存処理が完了する前に「保存しました」と表示されてしまいます。

さらに、保存処理で例外が発生しても、このイベントハンドラではその失敗を確認していません。

つまり、保存に失敗しているのに、画面上では成功したように見えてしまうのです。

これでは、利用者は保存できたと思って次の操作に進んでしまうかもしれません。

原因は、SaveDataAsync()を呼び出しただけで、完了を待っていないことです。

このように、処理を開始したまま完了を待たない使い方を、一般にfire-and-forgetと呼びます。

fire-and-forget自体が必ず悪いわけではありません。

ただし、処理の完了や失敗を誰が管理するのか、という点には注意が必要です。


6. awaitしてから成功を表示する

では、先ほどのコードを修正してみましょう。

private async void SaveButton_Click(
    object sender,
    RoutedEventArgs e)
{
    try
    {
        await SaveDataAsync();

        MessageBox.Show("保存しました");
    }
    catch (Exception ex)
    {
        MessageBox.Show(
            $"保存に失敗しました: {ex.Message}");
    }
}

今度は、SaveDataAsync()をawaitしています。

これにより、保存処理が正常に完了した場合だけ「保存しました」と表示されます。

保存処理で例外が発生した場合は、catchに入り、エラーメッセージが表示されます。

ここで重要なのは、awaitが単に例外を捕まえるためだけのものではないということです。

非同期処理が正常に完了したことを確認してから、次の処理へ進む

という役割もあります。

なお、イベントハンドラ自体はasync voidになっています。

これは、WPFのイベントハンドラがvoidを戻り値とする形式だからです。

前回の記事でも説明したように、イベントハンドラはasync voidを使う代表的なケースです。

ただし、async voidでは未処理例外を呼び出し元から通常のTaskのように扱えません。

そのため、イベントハンドラ内でも、必要な例外処理を行うことが大切です。


7. 実務で意識しておきたい3つのこと

非同期処理を扱うときは、次の3点を確認すると整理しやすくなります。

① 呼び出したTaskをawaitしているか

async Taskメソッドを呼び出しただけでは、処理の完了や失敗を確認したことにはなりません。

原則として、返されたTaskはawaitして扱います。

② try-catchはawaitを囲んでいるか

例外を捕まえたい場合は、awaitする場所をtry-catchで囲みます。

Taskを取得する場所だけを囲んでも、async Taskメソッド内部の例外は捕まえられません。

③ awaitしない場合、誰が失敗を管理するか

意図的にawaitしない設計にする場合は、例外処理や完了管理の仕組みを別途用意する必要があります。

「とりあえず呼び出しておく」という実装は、後から原因を追いにくい不具合につながることがあります。


まとめ

今回は、async Taskと例外処理の関係について整理しました。

ポイントは次のとおりです。

  • async Taskメソッド内で処理されなかった例外は、返されたTaskに記録される
  • 非同期メソッドを呼び出しただけでは、呼び出し元のcatchでその例外を捕まえられない
  • awaitすると、失敗したTaskの例外をその場所で受け取れる
  • 例外を捕まえたい場合は、awaitをtry-catchで囲む
  • awaitは、処理が正常に完了したことを確認してから次へ進むためにも重要
  • awaitしない場合は、完了や失敗を誰が管理するのか考える必要がある

async Taskにすれば、それだけで例外処理が安全になるわけではありません。

大切なのは、非同期処理の完了と失敗を、どこで受け取るのかを理解することです。

async、Task、awaitの役割を分けて考えると、非同期処理の動きが少しずつ見えてくると思います。

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?