[C#] awaitとTaskを使った非同期メソッドの待機処理を実装する方法

C#では、awaitとTaskを使って非同期メソッドの待機処理を実装できます。

非同期メソッドはasyncキーワードを付けて定義し、TaskまたはTask<T>を返します。

awaitキーワードを使うことで、非同期処理が完了するまで待機しつつ、スレッドをブロックせずに他の処理を進めることが可能です。

例えば、Task.Delayを使って一定時間待機する非同期処理を実装できます。

awaitは非同期メソッド内でのみ使用可能です。

この記事でわかること

非同期処理の基本と利点
asyncとawaitの使い方
Taskクラスの詳細な機能
非同期メソッドの実装例
パフォーマンス最適化の手法

目次から探す

非同期処理の基本

同期処理と非同期処理の違い

同期処理: 処理が完了するまで次の処理を待つ。

例: データベースからデータを取得する際、取得が完了するまで他の処理は行われない。

非同期処理: 処理を開始した後、他の処理を並行して行うことができる。

例: データを取得している間に、ユーザーからの入力を受け付けることが可能。

非同期処理が必要な理由

ユーザー体験の向上: アプリケーションが応答し続けることで、ユーザーが快適に操作できる。
リソースの効率的な利用: CPUやメモリを有効活用し、待機時間を短縮する。
スケーラビリティ: 多数のリクエストを同時に処理することが可能になり、サーバーの負荷を軽減する。

C#における非同期処理の仕組み

C#では、非同期処理を実現するためにasyncとawaitキーワードを使用します。

これにより、非同期メソッドを簡単に定義し、呼び出すことができます。

Taskクラスは、非同期処理の結果を表現するために使用されます。

これにより、非同期処理の状態を管理し、結果を取得することが可能です。

Taskクラスの役割

非同期処理の結果を表す: Taskは非同期メソッドの結果を保持します。
処理の状態を管理: Taskは処理が完了したかどうか、成功したか失敗したかを確認できます。
並列処理のサポート: 複数のTaskを同時に実行し、結果を待つことができます。

asyncとawaitの基本的な使い方

asyncキーワードを使って非同期メソッドを定義し、awaitキーワードを使って非同期処理の完了を待機します。

以下は基本的な使い方の例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // 非同期メソッドを呼び出す
        string result = await GetDataAsync();
        Console.WriteLine(result); // 結果を表示
    }
    // 非同期メソッドの定義
    static async Task<string> GetDataAsync()
    {
        // 2秒待機する非同期処理
        await Task.Delay(2000); 
        return "データ取得完了"; // 結果を返す
    }
}

データ取得完了

この例では、GetDataAsyncメソッドが2秒間待機した後にデータを返します。

Mainメソッドでは、awaitを使って非同期処理の完了を待っています。

これにより、アプリケーションは応答を維持しながら非同期処理を行うことができます。

Taskクラスの詳細

TaskとTask<T>の違い

スクロールできます

特徴	`Task`	`Task<T>`
戻り値	なし	型指定の戻り値あり
使用目的	処理の完了を示す	処理結果を返す
例	`Task.Run(() => { /* 処理 */ })`	`Task<int>.Run(() => { return 42; })`

Taskは戻り値がない非同期処理を表し、Task<T>は指定した型の戻り値を持つ非同期処理を表します。

これにより、必要に応じて適切なクラスを選択できます。

Taskのライフサイクル

Taskのライフサイクルは以下のステージを経ます:

未開始: Taskが作成されたが、まだ実行されていない状態。
実行中: Taskが実行されている状態。
完了: Taskが正常に完了したか、例外が発生した状態。

これらの状態は、Task.Statusプロパティを使用して確認できます。

Task.Runの使い方

Task.Runメソッドは、指定した処理を非同期に実行するために使用されます。

以下はその基本的な使い方の例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // Task.Runを使って非同期処理を実行
        int result = await Task.Run(() => CalculateSum(100));
        Console.WriteLine($"合計: {result}"); // 結果を表示
    }
    // 合計を計算するメソッド
    static int CalculateSum(int n)
    {
        int sum = 0;
        for (int i = 1; i <= n; i++)
        {
            sum += i; // 合計を計算
        }
        return sum; // 合計を返す
    }
}

合計: 5050

この例では、Task.Runを使用してCalculateSumメソッドを非同期に実行し、その結果を待機しています。

Task.Delayを使った非同期処理のシミュレーション

Task.Delayメソッドは、指定した時間だけ非同期処理を遅延させるために使用されます。

以下はその例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("処理開始");
        await Task.Delay(3000); // 3秒待機
        Console.WriteLine("処理完了"); // 完了メッセージを表示
    }
}

処理開始
(3秒後)
処理完了

この例では、Task.Delayを使用して3秒間の遅延をシミュレーションしています。

非同期処理中も他の処理を行うことができます。

Task.WhenAllとTask.WhenAnyの使い方

Task.WhenAllとTask.WhenAnyは、複数のTaskを同時に管理するためのメソッドです。

Task.WhenAll: すべてのTaskが完了するのを待ちます。
Task.WhenAny: 最初に完了したTaskを待ちます。

以下はそれぞれの使い方の例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        Task task1 = Task.Delay(2000); // 2秒待機
        Task task2 = Task.Delay(3000); // 3秒待機
        // Task.WhenAllを使ってすべてのタスクが完了するのを待つ
        await Task.WhenAll(task1, task2);
        Console.WriteLine("すべてのタスクが完了しました。");
        // Task.WhenAnyを使って最初に完了したタスクを待つ
        Task firstCompletedTask = await Task.WhenAny(task1, task2);
        Console.WriteLine("最初に完了したタスクが完了しました。");
    }
}

すべてのタスクが完了しました。
最初に完了したタスクが完了しました。

この例では、Task.WhenAllを使用してすべてのタスクが完了するのを待ち、Task.WhenAnyを使用して最初に完了したタスクを待っています。

これにより、複数の非同期処理を効率的に管理できます。

asyncとawaitの使い方

asyncメソッドの定義方法

asyncメソッドは、asyncキーワードをメソッドの定義に追加することで作成します。

このキーワードを使うことで、メソッド内でawaitを使用できるようになります。

以下はasyncメソッドの基本的な定義方法の例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // 非同期メソッドを呼び出す
        await PerformAsyncOperation();
    }
    // asyncメソッドの定義
    static async Task PerformAsyncOperation()
    {
        // ここに非同期処理を記述
        await Task.Delay(1000); // 1秒待機
        Console.WriteLine("非同期処理が完了しました。"); // 完了メッセージを表示
    }
}

(1秒後)
非同期処理が完了しました。

この例では、PerformAsyncOperationメソッドがasyncとして定義されており、awaitを使って非同期処理を行っています。

awaitの基本的な使い方

awaitキーワードは、非同期メソッドの実行を一時停止し、指定したTaskが完了するのを待ちます。

awaitを使うことで、非同期処理の結果を簡単に取得できます。

以下はその基本的な使い方の例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // awaitを使って非同期メソッドの結果を待つ
        string result = await GetDataAsync();
        Console.WriteLine(result); // 結果を表示
    }
    // 非同期メソッドの定義
    static async Task<string> GetDataAsync()
    {
        await Task.Delay(2000); // 2秒待機
        return "データ取得完了"; // 結果を返す
    }
}

(2秒後)
データ取得完了

この例では、awaitを使ってGetDataAsyncメソッドの結果を待機し、取得したデータを表示しています。

awaitの内部動作

awaitは、非同期メソッドの実行を一時停止し、指定したTaskが完了するまで制御を戻します。

Taskが完了すると、awaitの後のコードが実行されます。

この動作により、UIスレッドをブロックせずに非同期処理を行うことができます。

awaitを使った非同期メソッドの呼び出し

awaitを使うことで、非同期メソッドを簡単に呼び出し、その結果を待つことができます。

以下はその例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // awaitを使って非同期メソッドを呼び出す
        string result = await FetchDataAsync();
        Console.WriteLine(result); // 結果を表示
    }
    // 非同期メソッドの定義
    static async Task<string> FetchDataAsync()
    {
        await Task.Delay(1500); // 1.5秒待機
        return "データ取得成功"; // 結果を返す
    }
}

(1.5秒後)
データ取得成功

この例では、FetchDataAsyncメソッドをawaitを使って呼び出し、その結果を表示しています。

awaitを使う際の注意点

UIスレッドのブロックを避ける: awaitを使用することで、UIスレッドをブロックせずに非同期処理を行うことができます。
asyncメソッド内でのみ使用: awaitはasyncメソッド内でのみ使用可能です。
戻り値の型に注意: awaitを使用するメソッドは、TaskまたはTask<T>を返す必要があります。

awaitと例外処理

awaitを使用する際、非同期メソッド内で発生した例外は、呼び出し元のメソッドに伝播します。

これにより、通常のtry-catchブロックを使って例外処理を行うことができます。

以下はその例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        try
        {
            // awaitを使って非同期メソッドを呼び出す
            string result = await ThrowExceptionAsync();
            Console.WriteLine(result); // 結果を表示
        }
        catch (Exception ex)
        {
            Console.WriteLine($"例外が発生しました: {ex.Message}"); // 例外メッセージを表示
        }
    }
    // 例外をスローする非同期メソッド
    static async Task<string> ThrowExceptionAsync()
    {
        await Task.Delay(1000); // 1秒待機
        throw new InvalidOperationException("エラーが発生しました"); // 例外をスロー
    }
}

(1秒後)
例外が発生しました: エラーが発生しました

この例では、ThrowExceptionAsyncメソッド内で例外が発生し、Mainメソッドでキャッチされています。

awaitを使用することで、非同期処理内の例外を適切に処理できます。

非同期メソッドの実装例

非同期メソッドの基本的な実装例

非同期メソッドは、asyncキーワードを使って定義し、awaitを使って非同期処理を待機します。

以下は基本的な非同期メソッドの実装例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // 非同期メソッドを呼び出す
        string result = await SimpleAsyncMethod();
        Console.WriteLine(result); // 結果を表示
    }
    // 非同期メソッドの定義
    static async Task<string> SimpleAsyncMethod()
    {
        await Task.Delay(1000); // 1秒待機
        return "非同期処理が完了しました"; // 結果を返す
    }
}

(1秒後)
非同期処理が完了しました

この例では、SimpleAsyncMethodが1秒待機した後に結果を返します。

Mainメソッドでその結果を待機し、表示しています。

Task.Delayを使った非同期処理の例

Task.Delayを使用して、指定した時間だけ待機する非同期処理の例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("処理開始");
        await WaitForSecondsAsync(3); // 3秒待機
        Console.WriteLine("処理完了"); // 完了メッセージを表示
    }
    // 指定した秒数待機する非同期メソッド
    static async Task WaitForSecondsAsync(int seconds)
    {
        await Task.Delay(seconds * 1000); // 秒数をミリ秒に変換して待機
    }
}

処理開始
(3秒後)
処理完了

この例では、WaitForSecondsAsyncメソッドを使って3秒間待機し、その後に完了メッセージを表示しています。

複数の非同期メソッドを並列実行する例

複数の非同期メソッドを並列に実行し、すべての処理が完了するのを待つ例です。

Task.WhenAllを使用します。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // 複数の非同期メソッドを並列に実行
        await ExecuteMultipleAsyncMethods();
    }
    static async Task ExecuteMultipleAsyncMethods()
    {
        Task task1 = Task.Delay(2000); // 2秒待機
        Task task2 = Task.Delay(3000); // 3秒待機
        await Task.WhenAll(task1, task2); // すべてのタスクが完了するのを待つ
        Console.WriteLine("すべての非同期処理が完了しました。"); // 完了メッセージを表示
    }
}

(3秒後)
すべての非同期処理が完了しました。

この例では、2つの非同期処理を並列に実行し、最も長い処理が完了するのを待っています。

非同期メソッドの戻り値を扱う方法

非同期メソッドは、Task<T>を返すことで戻り値を持つことができます。

以下はその例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // 非同期メソッドの戻り値を取得
        int result = await CalculateSumAsync(100);
        Console.WriteLine($"合計: {result}"); // 結果を表示
    }
    // 合計を計算する非同期メソッド
    static async Task<int> CalculateSumAsync(int n)
    {
        await Task.Delay(2000); // 2秒待機
        int sum = 0;
        for (int i = 1; i <= n; i++)
        {
            sum += i; // 合計を計算
        }
        return sum; // 合計を返す
    }
}

(2秒後)
合計: 5050

この例では、CalculateSumAsyncメソッドが合計を計算し、その結果をMainメソッドで表示しています。

非同期メソッドのキャンセル処理

非同期メソッドにキャンセル機能を追加するには、CancellationTokenを使用します。

以下はその例です。

using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        CancellationTokenSource cts = new CancellationTokenSource();
        Task task = LongRunningOperationAsync(cts.Token);
        // 2秒後にキャンセル
        await Task.Delay(2000);
        cts.Cancel(); // キャンセルを要求
        try
        {
            await task; // タスクの完了を待つ
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("処理がキャンセルされました。"); // キャンセルメッセージを表示
        }
    }
    // 長時間実行される非同期メソッド
    static async Task LongRunningOperationAsync(CancellationToken token)
    {
        for (int i = 0; i < 5; i++)
        {
            token.ThrowIfCancellationRequested(); // キャンセル要求をチェック
            await Task.Delay(1000); // 1秒待機
            Console.WriteLine($"処理中... {i + 1}"); // 処理中メッセージを表示
        }
    }
}

処理中... 1
(1秒後)
処理中... 2
(1秒後)
処理がキャンセルされました。

この例では、LongRunningOperationAsyncメソッドがキャンセル要求を受け取ると、OperationCanceledExceptionをスローします。

Mainメソッドでは、キャンセルされた場合の処理を行っています。

非同期処理のパフォーマンス最適化

スレッドのブロッキングを避ける方法

非同期処理を行う際、スレッドのブロッキングを避けることが重要です。

ブロッキングが発生すると、アプリケーションの応答性が低下し、パフォーマンスが悪化します。

以下の方法でブロッキングを避けることができます。

awaitを使用する: 非同期メソッド内でawaitを使用することで、処理が完了するまでスレッドをブロックせずに待機できます。
長時間実行される処理を非同期にする: データベースアクセスやファイルI/Oなどの長時間実行される処理は、非同期メソッドとして実装し、awaitを使って待機します。
UIスレッドをブロックしない: UIアプリケーションでは、UIスレッドをブロックしないように注意し、すべての重い処理を非同期で実行します。

ConfigureAwait(false)の使い方と効果

ConfigureAwait(false)を使用することで、非同期メソッドの待機時にコンテキストを捕捉しないように設定できます。

これにより、パフォーマンスが向上し、デッドロックのリスクを減少させることができます。

以下はその使い方の例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        // ConfigureAwait(false)を使用して非同期メソッドを呼び出す
        string result = await GetDataAsync().ConfigureAwait(false);
        Console.WriteLine(result); // 結果を表示
    }
    static async Task<string> GetDataAsync()
    {
        await Task.Delay(2000).ConfigureAwait(false); // 2秒待機
        return "データ取得完了"; // 結果を返す
    }
}

この例では、ConfigureAwait(false)を使用することで、待機中にコンテキストを捕捉せず、パフォーマンスを向上させています。

特にライブラリやバックグラウンド処理での使用が推奨されます。

非同期処理のデッドロックを防ぐ方法

非同期処理においてデッドロックが発生することがあります。

以下の方法でデッドロックを防ぐことができます。

awaitを使用する: 非同期メソッド内でawaitを使用し、同期的に待機しないようにします。
ConfigureAwait(false)を使用する: UIスレッドでのデッドロックを防ぐために、ConfigureAwait(false)を使用してコンテキストを捕捉しないようにします。
非同期メソッドを同期的に呼び出さない: 非同期メソッドを同期的に呼び出すことは避け、常にawaitを使用して非同期的に呼び出します。

非同期処理のオーバーヘッドを最小化する方法

非同期処理にはオーバーヘッドが伴いますが、以下の方法でそのオーバーヘッドを最小化できます。

必要な場合のみ非同期を使用する: 短時間で完了する処理に対して非同期を使用することは避け、必要な場合にのみ非同期メソッドを使用します。
Task.Runを適切に使用する: CPUバウンドな処理を非同期に実行する場合は、Task.Runを使用してバックグラウンドスレッドで実行します。

ただし、I/Oバウンドな処理にはTask.Runは不要です。

非同期メソッドの設計を見直す: 非同期メソッドの設計を見直し、必要な処理を最小限に抑えることで、オーバーヘッドを減少させます。

これらの方法を実践することで、非同期処理のパフォーマンスを最適化し、アプリケーションの応答性を向上させることができます。

応用例：非同期処理を使った実践的なシナリオ

Web API呼び出しの非同期処理

Web APIを呼び出す際には、非同期処理を使用することで、応答を待つ間に他の処理を行うことができます。

以下は、HttpClientを使用して非同期にWeb APIを呼び出す例です。

using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        string url = "https://api.example.com/data"; // APIのURL
        string result = await CallApiAsync(url); // 非同期にAPIを呼び出す
        Console.WriteLine(result); // 結果を表示
    }
    static async Task<string> CallApiAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            HttpResponseMessage response = await client.GetAsync(url); // APIを呼び出す
            response.EnsureSuccessStatusCode(); // 成功を確認
            return await response.Content.ReadAsStringAsync(); // 結果を文字列として返す
        }
    }
}

この例では、HttpClientを使用して非同期にWeb APIを呼び出し、結果を表示しています。

APIの応答を待つ間、他の処理を行うことができます。

ファイルI/Oの非同期処理

ファイルの読み書きも非同期で行うことができます。

以下は、非同期にファイルを読み込む例です。

using System;
using System.IO;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        string filePath = "example.txt"; // 読み込むファイルのパス
        string content = await ReadFileAsync(filePath); // 非同期にファイルを読み込む
        Console.WriteLine(content); // 結果を表示
    }
    static async Task<string> ReadFileAsync(string filePath)
    {
        using (StreamReader reader = new StreamReader(filePath))
        {
            return await reader.ReadToEndAsync(); // ファイルの内容を非同期に読み込む
        }
    }
}

この例では、StreamReaderを使用して非同期にファイルを読み込み、その内容を表示しています。

ファイルの読み込み中も他の処理を行うことができます。

データベースアクセスの非同期処理

データベースへのアクセスも非同期で行うことができます。

以下は、Entity Frameworkを使用して非同期にデータを取得する例です。

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
class Program
{
    static async Task Main(string[] args)
    {
        using (var context = new MyDbContext())
        {
            var users = await context.Users.ToListAsync(); // 非同期にユーザーを取得
            foreach (var user in users)
            {
                Console.WriteLine(user.Name); // ユーザー名を表示
            }
        }
    }
}
public class MyDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
}
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

この例では、Entity Frameworkを使用して非同期にデータベースからユーザー情報を取得し、表示しています。

データベースアクセス中も他の処理を行うことができます。

UIスレッドをブロックしない非同期処理

UIアプリケーションでは、UIスレッドをブロックしないように非同期処理を行うことが重要です。

以下は、WPFアプリケーションで非同期にボタンのクリックイベントを処理する例です。

using System;
using System.Threading.Tasks;
using System.Windows;
namespace AsyncExample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            // 非同期に長時間処理を実行
            await LongRunningOperationAsync();
            MessageBox.Show("処理が完了しました。"); // 完了メッセージを表示
        }
        private async Task LongRunningOperationAsync()
        {
            await Task.Delay(5000); // 5秒待機
        }
    }
}

この例では、ボタンがクリックされると非同期に長時間処理を実行し、UIスレッドをブロックせずに処理が完了した後にメッセージボックスを表示します。

タイムアウト付きの非同期処理

非同期処理にタイムアウトを設定することで、処理が長時間かかる場合に適切に対処できます。

以下は、CancellationTokenSourceを使用してタイムアウトを設定する例です。

using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        using (CancellationTokenSource cts = new CancellationTokenSource())
        {
            cts.CancelAfter(3000); // 3秒後にキャンセル
            try
            {
                await LongRunningOperationAsync(cts.Token); // 非同期処理を実行
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("処理がタイムアウトしました。"); // タイムアウトメッセージを表示
            }
        }
    }
    static async Task LongRunningOperationAsync(CancellationToken token)
    {
        await Task.Delay(5000, token); // 5秒待機(キャンセル可能)
    }
}

この例では、CancellationTokenSourceを使用して3秒後にキャンセルを要求し、LongRunningOperationAsyncメソッドがタイムアウトした場合に例外をキャッチしてメッセージを表示しています。

これにより、長時間かかる処理に対して適切に対処できます。

よくある質問

asyncメソッドは必ずawaitを使う必要がありますか？

asyncメソッドは必ずしもawaitを使う必要はありません。

asyncキーワードを使うことで、非同期メソッドとして定義されますが、awaitを使用しない場合、メソッドは即座にTaskを返します。

この場合、メソッド内で非同期処理を行っても、呼び出し元はその結果を待たずに次の処理を続行します。

ただし、awaitを使用しないと、非同期処理の完了を待たずに次の処理に進むため、結果を正しく取得できない可能性があります。

awaitを使わないとどうなりますか？

awaitを使わない場合、非同期メソッドは即座に制御を返します。

これにより、呼び出し元は非同期処理の完了を待たずに次の処理を実行します。

結果として、非同期処理が完了する前に次の処理が実行されるため、非同期処理の結果を正しく取得できないことがあります。

また、非同期メソッド内で例外が発生した場合、その例外は呼び出し元に伝播しないため、エラーハンドリングが難しくなることがあります。

非同期メソッドの例外処理はどうすればいいですか？

非同期メソッド内で発生した例外は、awaitを使用して呼び出すことで、呼び出し元に伝播します。

例外処理は通常のメソッドと同様にtry-catchブロックを使用して行います。

以下はその例です。

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        try
        {
            // 非同期メソッドを呼び出す
            string result = await ThrowExceptionAsync();
            Console.WriteLine(result); // 結果を表示
        }
        catch (Exception ex)
        {
            Console.WriteLine($"例外が発生しました: {ex.Message}"); // 例外メッセージを表示
        }
    }
    // 例外をスローする非同期メソッド
    static async Task<string> ThrowExceptionAsync()
    {
        await Task.Delay(1000); // 1秒待機
        throw new InvalidOperationException("エラーが発生しました"); // 例外をスロー
    }
}

この例では、ThrowExceptionAsyncメソッド内で例外が発生し、Mainメソッドでキャッチされています。

awaitを使用することで、非同期処理内の例外を適切に処理できます。