C#における非同期処理の基本的なポイントを実例13選でおさらい

●非同期処理とは？

現代のソフトウェア開発において、非同期処理は欠かせない技術の1つです。

特にC#を使ったアプリケーション開発の現場では、非同期処理を適切に活用することが求められています。

非同期処理とは、簡単に言えば、プログラムの一部を別のスレッドで実行することです。

つまり、メインスレッドとは独立して処理を進めることができるのです。

これにより、メインスレッドがブロックされることなく、アプリケーションのパフォーマンスと応答性を向上させることができます。

○非同期処理の仕組み

非同期処理の仕組みを理解するには、まずスレッドの概念を理解する必要があります。

スレッドとは、プログラムの実行単位のことです。

通常、アプリケーションはメインスレッドで実行されますが、非同期処理では別のスレッドを作成し、そのスレッドで処理を実行します。

非同期処理を開始すると、メインスレッドはブロックされずに次の処理を続行します。

一方、非同期処理を実行するスレッドは、バックグラウンドで処理を進めます。

非同期処理が完了すると、結果をメインスレッドに返します。

このように、非同期処理を使うことで、メインスレッドとバックグラウンドスレッドを並行して実行できるのです。

○非同期処理を使うメリット

非同期処理を使うことで、いくつかのメリットが得られます。

まず、アプリケーションのパフォーマンスが向上します。

非同期処理を使えば、時間のかかる処理をバックグラウンドで実行できるため、メインスレッドがブロックされることがありません。

これにより、アプリケーションの応答性が高まり、ユーザーエクスペリエンスが向上します。

次に、リソースの有効活用が可能になります。

非同期処理を使えば、CPUやI/Oなどのリソースを効率的に使えます。

たとえば、ファイルの読み書きや、ネットワーク通信などの処理を非同期で実行することで、リソースの無駄を減らせます。

さらに、非同期処理を使えば、アプリケーションの設計がシンプルになります。

同期処理では、処理が完了するまでメインスレッドがブロックされるため、複雑な制御が必要になります。

一方、非同期処理を使えば、処理の流れを簡潔に表現できます。

○非同期処理の注意点

非同期処理を使う際は、デッドロックに注意する必要があります。

デッドロックとは、複数のスレッドが互いに他のスレッドの処理が完了するのを待ち続ける状態のことです。

非同期処理を使う際は、スレッド間の依存関係に注意し、デッドロックを避けるようにしましょう。

また、例外処理にも気をつける必要があります。

非同期処理では、例外が発生してもメインスレッドでは検知できない場合があります。

そのため、非同期処理内で適切に例外処理を行う必要があります。

続いて、UIコンポーネントへのアクセスにも注意が必要です。

UIコンポーネントは、作成されたスレッドからしかアクセスできません。

そのため、バックグラウンドスレッドからUIコンポーネントにアクセスしようとすると、例外が発生します。

UIコンポーネントへのアクセスが必要な場合は、Dispatcherなどを使って、UIスレッドから安全にアクセスする必要があります。

●非同期処理の基本

C#で非同期処理を行うための基本的な方法について見ていきましょう。

非同期処理を実装するには、いくつかのキーワードやクラスを理解する必要があります。

まずは、非同期処理を行うメソッドを定義する方法から始めましょう。

C#では、非同期メソッドを定義するために、メソッドの戻り値型としてTaskまたはTaskを使用します。

Taskは非同期処理の結果を表すクラスで、TaskはTaskを継承し、非同期処理の結果として値を返すことができます。

○サンプルコード1：非同期メソッドの定義

非同期メソッドを定義するサンプルコードを見てみましょう。

public async Task<int> GetValueAsync()
{
    // 非同期処理を行う
    int result = await Task.Run(() => 
    {
        // 時間のかかる処理をここに書く
        Thread.Sleep(1000); // 1秒待機するサンプル
        return 42;
    });

    return result;
}

このコードでは、GetValueAsync()メソッドを非同期メソッドとして定義しています。

メソッドの戻り値型はTaskで、非同期処理の結果として整数値を返します。

メソッド内では、Task.Runメソッドを使って非同期処理を開始し、awaitキーワードを使って非同期処理の完了を待ちます。

Task.Runメソッドは、指定された処理を別のスレッドで実行するためのメソッドです。

この例では、Thread.Sleepメソッドを使って1秒間待機し、その後42を返しています。

実際のアプリケーションでは、ここでファイルの読み書きやネットワーク通信などの時間のかかる処理を行うことになります。

○サンプルコード2：非同期メソッドの呼び出し

非同期メソッドを呼び出すには、awaitキーワードを使います。

public async Task CallAsync()
{
    int result = await GetValueAsync();
    Console.WriteLine($"Result: {result}");
}

このコードでは、CallAsync()メソッドから、先ほど定義したGetValueAsync()メソッドを呼び出しています。

awaitキーワードを使って、GetValueAsync()メソッドの完了を待ち、結果を取得しています。取得した結果は、Consoleクラスを使って出力しています。

実行結果↓

Result: 42

GetValueAsync()メソッドから返された42が出力されていることがわかります。

○サンプルコード3：タスクの待機

複数の非同期処理を実行する場合、それらのタスクが完了するのを待つために、Task.WhenAllメソッドを使うことができます。

public async Task WaitMultipleTasksAsync()
{
    Task<int> task1 = GetValueAsync();
    Task<int> task2 = GetValueAsync();
    Task<int> task3 = GetValueAsync();

    int[] results = await Task.WhenAll(task1, task2, task3);
    Console.WriteLine($"Results: {string.Join(", ", results)}");
}

このコードでは、GetValueAsync()メソッドを3回呼び出し、それぞれのタスクをtask1、task2、task3変数に格納しています。

その後、Task.WhenAllメソッドを使って、3つのタスクがすべて完了するのを待ちます。

Task.WhenAllメソッドは、指定されたタスクがすべて完了すると、それらのタスクの結果を配列として返します。

この例では、resultsという整数の配列に結果が格納されます。

実行結果↓

Results: 42, 42, 42

3つのタスクがすべて完了し、それぞれのタスクから42が返されたことがわかります。

○サンプルコード4：タスクの結果の取得

非同期メソッドの戻り値型がTaskの場合、タスクの結果を取得するにはResult・Propertyを使います。

ただし、Resultプロパティを使うと、呼び出し元のスレッドがブロックされるため、注意が必要です。

public async Task GetResultAsync()
{
    Task<int> task = GetValueAsync();
    int result = task.Result;
    Console.WriteLine($"Result: {result}");
}

このコードでは、GetValueAsync()メソッドを呼び出し、タスクをtask変数に格納しています。

その後、taskのResultプロパティを使って、タスクの結果を取得しています。

実行結果↓

Result: 42

GetValueAsync()メソッドから返された42が出力されています。

ただし、先ほども述べたように、Resultプロパティを使うと呼び出し元のスレッドがブロックされるため、デッドロックが発生する可能性があります。

そのため、できる限りawaitキーワードを使って非同期的にタスクの完了を待つようにしましょう。

●async/awaitキーワードの使い方

C#で非同期処理を行う際に、async/awaitキーワードは非常に重要な役割を果たします。

asyncキーワードは、メソッドが非同期処理を含むことを表すために使用され、awaitキーワードは、非同期処理の完了を待機するために使用されます。

async/awaitキーワードを使うことで、非同期処理のコードを同期処理のように書くことができ、コードの可読性が大幅に向上します。

また、awaitキーワードを使って非同期処理の完了を待機することで、デッドロックを回避し、アプリケーションのパフォーマンスを改善することができます。

○サンプルコード5：async/awaitを使った非同期処理

それでは、async/awaitキーワードを使った非同期処理の例を見ていきましょう。

public async Task<int> CalculateAsync(int a, int b)
{
    int result = await Task.Run(() =>
    {
        // 時間のかかる処理を行う
        Thread.Sleep(1000);
        return a + b;
    });

    return result;
}

public async Task CallCalculateAsync()
{
    int result = await CalculateAsync(10, 20);
    Console.WriteLine($"Result: {result}");
}

このコードでは、CalculateAsync()メソッドを非同期メソッドとして定義しています。

メソッド内では、Task.Runメソッドを使って非同期処理を開始し、awaitキーワードを使って非同期処理の完了を待機しています。

非同期処理では、2つの引数を加算し、結果を返しています。

CallCalculateAsync()メソッドでは、CalculateAsync()メソッドを呼び出し、awaitキーワードを使って非同期処理の完了を待機しています。

非同期処理の結果は、result変数に格納され、Consoleクラスを使って出力されます。

実行結果↓

Result: 30

CalculateAsync()メソッドから返された30が出力されています。

○サンプルコード6：複数の非同期処理の並列実行

複数の非同期処理を並列に実行する場合、Task.WhenAllメソッドを使うことができます。

public async Task<int> CalculateAsync(int a, int b)
{
    int result = await Task.Run(() =>
    {
        // 時間のかかる処理を行う
        Thread.Sleep(1000);
        return a + b;
    });

    return result;
}

public async Task CallCalculateAsync()
{
    Task<int> task1 = CalculateAsync(10, 20);
    Task<int> task2 = CalculateAsync(30, 40);
    Task<int> task3 = CalculateAsync(50, 60);

    int[] results = await Task.WhenAll(task1, task2, task3);
    Console.WriteLine($"Results: {string.Join(", ", results)}");
}

このコードでは、CalculateAsync()メソッドを3回呼び出し、それぞれのタスクをtask1、task2、task3変数に格納しています。

その後、Task.WhenAllメソッドを使って、3つのタスクがすべて完了するのを待ちます。

Task.WhenAllメソッドは、指定されたタスクがすべて完了すると、それらのタスクの結果を配列として返します。

この例では、resultsという整数の配列に結果が格納されます。

実行結果↓

Results: 30, 70, 110

3つのタスクがすべて完了し、それぞれのタスクから返された結果が出力されています。

○サンプルコード7：非同期処理の直列実行

複数の非同期処理を直列に実行する場合、awaitキーワードを使って順番に処理を待機することができます。

public async Task<int> CalculateAsync(int a, int b)
{
    int result = await Task.Run(() =>
    {
        // 時間のかかる処理を行う
        Thread.Sleep(1000);
        return a + b;
    });

    return result;
}

public async Task CallCalculateAsync()
{
    int result1 = await CalculateAsync(10, 20);
    int result2 = await CalculateAsync(30, 40);
    int result3 = await CalculateAsync(50, 60);

    Console.WriteLine($"Results: {result1}, {result2}, {result3}");
}

このコードでは、CalculateAsync()メソッドを3回呼び出していますが、それぞれの呼び出しにawaitキーワードを使っています。

これにより、1つ目のCalculateAsync()メソッドが完了するまで待機し、その後2つ目のCalculateAsync()メソッドを呼び出します。

同様に、2つ目のCalculateAsync()メソッドが完了するまで待機し、その後3つ目のCalculateAsync()メソッドを呼び出します。

実行結果↓

Results: 30, 70, 110

3つのCalculateAsync()メソッドが順番に実行され、それぞれのメソッドから返された結果が出力されています。

●非同期処理のエラーハンドリング

非同期処理を使うと、アプリケーションのパフォーマンスを改善できる反面、エラーハンドリングが複雑になる場合があります。

非同期処理では、エラーが発生してもメインスレッドでは検知できないことがあるため、適切なエラー処理が必要です。

C#では、try-catch文を使ってエラーをキャッチし、適切に処理することができます。

また、複数の非同期処理を待機する場合、AggregateException型の例外が発生することがあります。

AggregateExceptionは、複数の例外を1つにまとめたものです。

○サンプルコード8：try-catchを使ったエラー処理

それでは、非同期処理のエラーハンドリングの例を見ていきましょう。

public async Task<int> DivideAsync(int a, int b)
{
    int result = await Task.Run(() =>
    {
        if (b == 0)
        {
            throw new DivideByZeroException("Cannot divide by zero.");
        }
        return a / b;
    });

    return result;
}

public async Task CallDivideAsync()
{
    try
    {
        int result = await DivideAsync(10, 0);
        Console.WriteLine($"Result: {result}");
    }
    catch (DivideByZeroException ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
}

このコードでは、DivideAsync()メソッドを非同期メソッドとして定義しています。メソッド内では、Task.Runメソッドを使って非同期処理を開始し、awaitキーワードを使って非同期処理の完了を待機しています。

非同期処理では、2つの引数を割り算しています。

ただし、第2引数が0の場合、DivideByZeroException例外をスローしています。

CallDivideAsync()メソッドでは、DivideAsync()メソッドを呼び出し、try-catch文を使ってエラーをキャッチしています。

DivideAsync()メソッドが成功した場合、結果をConsoleクラスを使って出力します。

DivideByZeroException例外が発生した場合、エラーメッセージをConsoleクラスを使って出力します。

実行結果↓

Error: Cannot divide by zero.

第2引数に0を指定しているため、DivideByZeroException例外が発生し、エラーメッセージが出力されています。

○サンプルコード9：AggregateExceptionの処理

public async Task<int> DivideAsync(int a, int b)
{
    int result = await Task.Run(() =>
    {
        if (b == 0)
        {
            throw new DivideByZeroException("Cannot divide by zero.");
        }
        return a / b;
    });

    return result;
}

public async Task CallDivideAsync()
{
    try
    {
        Task<int> task1 = DivideAsync(10, 2);
        Task<int> task2 = DivideAsync(20, 0);
        Task<int> task3 = DivideAsync(30, 3);

        int[] results = await Task.WhenAll(task1, task2, task3);
        Console.WriteLine($"Results: {string.Join(", ", results)}");
    }
    catch (AggregateException ex)
    {
        foreach (var innerException in ex.InnerExceptions)
        {
            Console.WriteLine($"Error: {innerException.Message}");
        }
    }
}

このコードでは、DivideAsync()メソッドを3回呼び出し、それぞれのタスクをtask1、task2、task3変数に格納しています。

その後、Task.WhenAllメソッドを使って、3つのタスクがすべて完了するのを待ちます。

ただし、task2では第2引数に0を指定しているため、DivideByZeroException例外が発生します。

Task.WhenAllメソッドは、いずれかのタスクで例外が発生した場合、AggregateException例外をスローします。

CallDivideAsync()メソッドでは、try-catch文を使ってAggregateException例外をキャッチしています。

AggregateException例外の内部には、複数の例外が含まれている可能性があるため、InnerExceptionsプロパティを使って、個々の例外を処理しています。

実行結果↓

Error: Cannot divide by zero.

task2でDivideByZeroException例外が発生したため、AggregateException例外がスローされ、エラーメッセージが出力されています。

●非同期処理のベストプラクティス

非同期処理を適切に使うことで、アプリケーションのパフォーマンスを改善できますが、いくつかのベストプラクティスに従うことが重要です。

ベストプラクティスを理解し、適用することで、非同期処理を効果的に活用し、コードの品質を向上させることができます。

それでは、非同期処理のベストプラクティスについて見ていきましょう。

○UIの応答性を維持する

非同期処理を使う主な目的の1つは、UIの応答性を維持することです。

長時間かかる処理をメインスレッドで実行すると、UIがフリーズし、ユーザーエクスペリエンスが低下します。

そのため、時間のかかる処理は非同期で実行することが重要です。

たとえば、ファイルの読み書きやネットワーク通信などの処理は、非同期で実行するべきです。

また、UIスレッドから直接非同期処理を呼び出すのではなく、バックグラウンドスレッドで非同期処理を実行し、結果をUIスレッドに返すようにしましょう。

○不要な非同期処理を避ける

非同期処理は便利ですが、過剰に使用すると、かえってパフォーマンスが低下する場合があります。

非同期処理にはオーバーヘッドがあるため、必要以上に非同期処理を使うことは避けましょう。

たとえば、単純な計算や、ごく短時間で完了する処理は、非同期で実行する必要はありません。

非同期処理を使うべきかどうかは、処理の内容や実行時間を考慮して判断する必要があります。

○サンプルコード10：ベストプラクティスを取り入れた例

それでは、ベストプラクティスを取り入れた非同期処理の例を見てみましょう。

public async Task<string> DownloadPageAsync(string url)
{
    using (var httpClient = new HttpClient())
    {
        try
        {
            // タイムアウトを設定する
            httpClient.Timeout = TimeSpan.FromSeconds(10);

            // 非同期でHTTPリクエストを送信する
            string content = await httpClient.GetStringAsync(url)
                .ConfigureAwait(false);

            return content;
        }
        catch (Exception ex)
        {
            // エラーをログに記録する
            Log.Error($"Failed to download page: {url}", ex);
            throw;
        }
    }
}

public async Task DisplayPageAsync(string url)
{
    try
    {
        // バックグラウンドスレッドで非同期処理を実行する
        string content = await Task.Run(() => DownloadPageAsync(url));

        // UIスレッドで結果を表示する
        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
            () =>
            {
                PageTextBlock.Text = content;
            });
    }
    catch (Exception ex)
    {
        // UIスレッドでエラーメッセージを表示する
        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
            () =>
            {
                ErrorTextBlock.Text = $"Error: {ex.Message}";
            });
    }
}

このコードでは、DownloadPageAsync()メソッドを非同期メソッドとして定義しています。

HttpClientクラスを使って、指定されたURLからHTMLコンテンツを非同期でダウンロードします。

タイムアウトを設定することで、無限に待機することを避けています。

また、ConfigureAwait(false)を使って、同期コンテキストを無視するようにしています。

DisplayPageAsync()メソッドでは、DownloadPageAsync()メソッドをバックグラウンドスレッドで実行し、結果をUIスレッドで表示しています。

非同期処理の結果は、Dispatcher.RunAsync()メソッドを使って、UIスレッドで処理されます。

エラーが発生した場合は、同様にUIスレッドでエラーメッセージを表示します。

●よくあるエラーと対処法

C#で非同期処理を行う際には、さまざまなエラーに遭遇する可能性があります。

エラーの原因を理解し、適切に対処することが重要です。

ここでは、非同期処理でよく発生するエラーとその対処法について見ていきましょう。

○NullReferenceException

NullReferenceExceptionは、nullである変数やプロパティにアクセスしようとしたときに発生するエラーです。

非同期処理では、タスクが完了する前にその結果にアクセスしようとすると、このエラーが発生することがあります。

たとえば、次のようなコードがあるとします。

public async Task<string> GetValueAsync()
{
    return await Task.Run(() =>
    {
        Thread.Sleep(1000);
        return "Hello, World!";
    });
}

public void CallGetValueAsync()
{
    string result = GetValueAsync().Result;
    Console.WriteLine(result);
}

このコードでは、GetValueAsync()メソッドを呼び出し、その結果をResultプロパティで取得しようとしています。

しかし、GetValueAsync()メソッドが完了する前にResultプロパティにアクセスしているため、NullReferenceExceptionが発生します。

この問題を避けるには、awaitキーワードを使って非同期処理の完了を待機するようにします。

public async void CallGetValueAsync()
{
    string result = await GetValueAsync();
    Console.WriteLine(result);
}

このように、CallGetValueAsync()メソッドをasyncキーワードで修飾し、awaitキーワードを使ってGetValueAsync()メソッドの完了を待機することで、NullReferenceExceptionを回避できます。

○InvalidOperationException

InvalidOperationExceptionは、操作が無効であるときに発生するエラーです。

非同期処理では、同期コンテキストを無視せずに、UIスレッドから直接非同期メソッドを呼び出すと、このエラーが発生することがあります。

たとえば、次のようなコードがあるとします。

public async Task<string> GetValueAsync()
{
    return await Task.Run(() =>
    {
        Thread.Sleep(1000);
        return "Hello, World!";
    });
}

private void Button_Click(object sender, RoutedEventArgs e)
{
    string result = GetValueAsync().Result;
    TextBlock.Text = result;
}

このコードでは、ボタンがクリックされたときに、GetValueAsync()メソッドを呼び出し、その結果をTextBlockに表示しようとしています。

しかし、UIスレッドから直接非同期メソッドを呼び出し、Resultプロパティで結果を取得しようとしているため、InvalidOperationExceptionが発生します。

この問題を避けるには、非同期メソッドの呼び出しを、UIスレッドとは別のスレッドで行うようにします。

private async void Button_Click(object sender, RoutedEventArgs e)
{
    string result = await Task.Run(() => GetValueAsync());
    TextBlock.Text = result;
}

このように、ボタンのクリックイベントハンドラをasyncキーワードで修飾し、Task.Run()メソッドを使って非同期メソッドの呼び出しを別スレッドで行うことで、InvalidOperationExceptionを回避できます。

○ObjectDisposedException

ObjectDisposedExceptionは、すでに破棄されたオブジェクトを使用しようとしたときに発生するエラーです。

非同期処理では、ファイルやデータベース接続などのリソースを使用する場合、非同期処理の完了前にそれらのリソースが破棄されると、このエラーが発生することがあります。

たとえば、次のようなコードがあるとします。

public async Task ReadFileAsync(string filePath)
{
    using (var reader = new StreamReader(filePath))
    {
        string content = await reader.ReadToEndAsync();
        Console.WriteLine(content);
    }
}

public async Task ProcessFilesAsync(string[] filePaths)
{
    foreach (var filePath in filePaths)
    {
        await ReadFileAsync(filePath);
    }
}

このコードでは、ReadFileAsync()メソッドでファイルを読み込み、その内容を出力しています。

ProcessFilesAsync()メソッドでは、複数のファイルパスを受け取り、それぞれのファイルを順番に読み込んでいます。

しかし、ReadFileAsync()メソッドの実行中に、ファイルが他のプロセスによって削除されると、ObjectDisposedExceptionが発生する可能性があります。

この問題を避けるには、ファイルの存在を確認してから読み込むようにします。

public async Task ReadFileAsync(string filePath)
{
    if (File.Exists(filePath))
    {
        using (var reader = new StreamReader(filePath))
        {
            string content = await reader.ReadToEndAsync();
            Console.WriteLine(content);
        }
    }
    else
    {
        Console.WriteLine($"File not found: {filePath}");
    }
}

このように、File.Exists()メソッドを使ってファイルの存在を確認し、ファイルが存在する場合にのみ読み込みを行うことで、ObjectDisposedExceptionを回避できます。

●非同期処理の応用例

非同期処理は、さまざまな場面で活用することができます。

ここでは、非同期処理の応用例として、非同期I/O、非同期ストリーミング、バックグラウンド処理の実装方法を見ていきましょう。

これらの応用例を理解することで、非同期処理の実践的な使い方を学ぶことができるでしょう。

それでは早速、具体的なサンプルコードを交えながら、非同期処理の応用例を探っていきましょう。

○サンプルコード11：非同期I/Oの実装

ファイルの読み書きなどのI/O処理は、時間がかかる場合があります。

そのため、I/O処理を非同期で行うことで、アプリケーションのパフォーマンスを改善できます。

C#では、非同期I/Oを実装するために、FileStreamクラスのReadAsync()メソッドやWriteAsync()メソッドを使用します。

public async Task CopyFileAsync(string sourceFile, string destinationFile)
{
    using (var sourceStream = new FileStream(sourceFile, FileMode.Open, FileAccess.Read))
    using (var destinationStream = new FileStream(destinationFile, FileMode.Create, FileAccess.Write))
    {
        await sourceStream.CopyToAsync(destinationStream);
    }
}

public async Task CallCopyFileAsync()
{
    await CopyFileAsync("source.txt", "destination.txt");
    Console.WriteLine("File copied successfully.");
}

このコードでは、CopyFileAsync()メソッドを使って、ファイルを非同期でコピーしています。

sourceFileで指定されたファイルを開き、destinationFileで指定されたファイルに書き込みます。

CopyToAsync()メソッドを使って、ファイルのコピーを非同期で行っています。

usingステートメントを使って、FileStreamオブジェクトのリソースを適切に解放しています。

CallCopyFileAsync()メソッドでは、CopyFileAsync()メソッドを呼び出し、ファイルのコピーが完了するのを待機しています。

ファイルのコピーが完了すると、メッセージを出力します。

実行結果↓

File copied successfully.

ファイルが正常にコピーされたことを示すメッセージが出力されます。

○サンプルコード12：非同期ストリーミングの実装

ネットワーク経由でデータを送受信する場合、ストリーミングを使うことが一般的です。

非同期処理を使って、ストリーミングを効率的に行うことができます。

C#では、非同期ストリーミングを実装するために、NetworkStreamクラスのReadAsync()メソッドやWriteAsync()メソッドを使用します。

public async Task SendDataAsync(NetworkStream stream, byte[] data)
{
    await stream.WriteAsync(data, 0, data.Length);
}

public async Task<byte[]> ReceiveDataAsync(NetworkStream stream)
{
    var buffer = new byte[1024];
    var receivedData = new List<byte>();

    int bytesRead;
    while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
    {
        receivedData.AddRange(buffer.Take(bytesRead));
    }

    return receivedData.ToArray();
}

public async Task RunClientAsync(string serverIp, int port)
{
    using (var client = new TcpClient())
    {
        await client.ConnectAsync(serverIp, port);
        using (var stream = client.GetStream())
        {
            var data = Encoding.UTF8.GetBytes("Hello, Server!");
            await SendDataAsync(stream, data);

            var receivedData = await ReceiveDataAsync(stream);
            var receivedMessage = Encoding.UTF8.GetString(receivedData);
            Console.WriteLine($"Received: {receivedMessage}");
        }
    }
}

このコードでは、SendDataAsync()メソッドを使って、データを非同期で送信しています。

NetworkStreamオブジェクトとバイト配列を受け取り、WriteAsync()メソッドを使ってデータを書き込みます。

ReceiveDataAsync()メソッドでは、データを非同期で受信しています。

ReadAsync()メソッドを使って、データを読み込み、受信したデータをListに追加します。

読み込むデータがなくなるまで繰り返し、最後にListをバイト配列に変換して返します。

RunClientAsync()メソッドでは、TcpClientを使ってサーバーに接続し、SendDataAsync()メソッドを使ってデータを送信した後、ReceiveDataAsync()メソッドを使ってデータを受信しています。

受信したデータをコンソールに出力します。

実行結果↓

Received: Hello, Client!

サーバーから受信したメッセージが出力されます。

○サンプルコード13：バックグラウンド処理の実装

時間のかかる処理を、バックグラウンドで実行することで、アプリケーションのレスポンスを維持することができます。

C#では、バックグラウンド処理を実装するために、BackgroundWorkerクラスを使用します。

public partial class MainWindow : Window
{
    private BackgroundWorker _worker;

    public MainWindow()
    {
        InitializeComponent();

        _worker = new BackgroundWorker();
        _worker.DoWork += Worker_DoWork;
        _worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
    }

    private void StartButton_Click(object sender, RoutedEventArgs e)
    {
        _worker.RunWorkerAsync();
    }

    private void Worker_DoWork(object sender, DoWorkEventArgs e)
    {
        // 時間のかかる処理を実行する
        Thread.Sleep(5000);
    }

    private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        MessageBox.Show("Background work completed.");
    }
}

このコードでは、BackgroundWorkerオブジェクトを作成し、DoWorkイベントとRunWorkerCompletedイベントを登録しています。

StartButton_Clickイベントハンドラで、RunWorkerAsync()メソッドを呼び出し、バックグラウンド処理を開始します。

Worker_DoWorkイベントハンドラには、実際の処理を記述します。

この例では、Thread.Sleep()を使って5秒間の待機を行っています。

Worker_RunWorkerCompletedイベントハンドラでは、バックグラウンド処理が完了した後に実行する処理を記述します。

この例では、メッセージボックスを表示しています。

実行すると、バックグラウンド処理が開始され、5秒後にメッセージボックスが表示されます。

その間、アプリケーションのUIはレスポンシブな状態を維持します。

まとめ

C#における非同期処理は、アプリケーションのパフォーマンスを向上させ、ユーザーエクスペリエンスを改善するために欠かせない技術です。

この記事では、非同期処理の基本的な概念から、async/awaitキーワードの使い方、エラーハンドリング、ベストプラクティス、そして実践的な応用例まで、幅広くカバーしてきました。

サンプルコードを交えながら、非同期処理の様々な側面を丁寧に解説してきましたが、いかがでしたでしょうか。

非同期処理は、C#プログラミングにおいて非常に重要なスキルです。

この記事で得た知識を活かして、実際のプロジェクトで非同期処理を活用していただければ幸いです。