[C#] asyncとtaskの使い方を徹底解説

2025-04-15更新日: 2025-04-15

C#のasyncとTaskは非同期プログラミングを実現するための重要な要素です。

asyncはメソッドに付ける修飾子で、そのメソッドが非同期であることを示します。

非同期メソッドは通常、TaskまたはTask<T>を返します。

Taskは非同期操作の完了を表すオブジェクトで、Task<T>は結果を返す非同期操作を表します。

awaitキーワードを使うことで、非同期メソッドの完了を待ちつつ、他の処理を続行できます。

これにより、UIスレッドをブロックせずにスムーズなユーザー体験を提供できます。

目次から探す

C#を使った求人

読み込み中…

非同期プログラミングの基礎

非同期プログラミングとは

非同期プログラミングは、プログラムが他のタスクを待たずに実行を続けることができるプログラミング手法です。

これにより、プログラムの応答性が向上し、特にI/O操作やネットワーク通信などの遅延が発生しやすい処理において効果的です。

C#では、asyncとawaitキーワードを使用して非同期プログラミングを実現します。

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

同期処理と非同期処理の違いを以下の表にまとめます。

特徴	同期処理	非同期処理
実行方法	タスクが順番に実行され、前のタスクが完了するまで次のタスクは開始されない	タスクが並行して実行され、他のタスクを待たずに次のタスクが開始される
応答性	低い	高い
使用例	計算処理、シンプルなロジック	ネットワーク通信、ファイルI/O

非同期プログラミングの利点

非同期プログラミングには以下のような利点があります。

応答性の向上: ユーザーインターフェースがブロックされることなく、スムーズな操作が可能になります。
リソースの効率的な利用: CPUやメモリの使用を最適化し、他のタスクを並行して実行することで、システム全体のパフォーマンスを向上させます。
スケーラビリティの向上: サーバーアプリケーションにおいて、同時に多くのリクエストを処理する能力が向上します。

これらの利点により、非同期プログラミングは現代のアプリケーション開発において重要な技術となっています。

asyncとawaitの基本

asyncキーワードの役割

asyncキーワードは、メソッドを非同期メソッドとして定義するために使用されます。

このキーワードをメソッドの宣言に付けることで、そのメソッドが非同期操作を含むことを示します。

asyncキーワード自体はメソッドの実行を非同期にするわけではなく、awaitキーワードと組み合わせて非同期処理を実現します。

public async Task SampleAsyncMethod()
{
    // 非同期メソッドの定義
}

awaitキーワードの使い方

awaitキーワードは、非同期メソッド内で非同期操作を待機するために使用されます。

awaitを使用することで、非同期操作が完了するまでメソッドの実行を一時停止し、完了後に続行します。

これにより、他のタスクが並行して実行される間、リソースを効率的に利用できます。

public async Task<string> FetchDataAsync()
{
    // 非同期操作を待機
    string data = await GetDataFromServerAsync();
    return data;
}

非同期メソッドの定義方法

非同期メソッドは、asyncキーワードを使用して定義され、通常はTaskまたはTask<T>を戻り値として持ちます。

Taskは非同期操作の完了を表し、Task<T>は非同期操作の結果を返します。

非同期メソッドは、awaitキーワードを使用して非同期操作を待機することができます。

public async Task<int> CalculateSumAsync(int a, int b)
{
    // 非同期メソッドの定義
    await Task.Delay(1000); // 1秒待機
    return a + b;
}
public static async Task Main(string[] args)
{
    int result = await CalculateSumAsync(3, 5);
    Console.WriteLine($"計算結果: {result}");
}

計算結果: 8

この例では、CalculateSumAsyncメソッドが非同期に実行され、1秒待機した後に計算結果を返します。

Mainメソッドでawaitを使用して結果を待機し、コンソールに出力しています。

TaskとTask<T>の理解

Taskの基本

Taskは、非同期操作を表現するための基本的なクラスです。

Taskオブジェクトは、非同期操作の完了を追跡し、操作が完了したときに通知を受け取ることができます。

Taskは、非同期メソッドの戻り値としてよく使用され、操作が完了するまで待機するためにawaitキーワードと組み合わせて使用されます。

public async Task PerformTaskAsync()
{
    // 非同期タスクの実行
    await Task.Run(() => 
    {
        // ここで重い処理を実行
        System.Threading.Thread.Sleep(2000); // 2秒待機
    });
}

Task<T>の使い方

Task<T>は、非同期操作の結果を返すために使用されるジェネリッククラスです。

Tは操作の結果の型を表します。

Task<T>を使用することで、非同期メソッドが完了したときに結果を受け取ることができます。

public async Task<int> ComputeValueAsync()
{
    // 非同期タスクの実行と結果の取得
    int result = await Task.Run(() => 
    {
        // 計算処理
        return 42;
    });
    return result;
}
public static async Task Main(string[] args)
{
    int value = await ComputeValueAsync();
    Console.WriteLine($"計算された値: {value}");
}

計算された値: 42

この例では、ComputeValueAsyncメソッドが非同期に実行され、計算結果をTask<int>として返します。

Mainメソッドでawaitを使用して結果を待機し、コンソールに出力しています。

Taskのライフサイクル

Taskのライフサイクルは以下のステージで構成されます。

Created: Taskが作成されたが、まだ開始されていない状態。
Running: Taskが実行中の状態。
Completed: Taskが正常に完了した状態。
Faulted: Taskが例外によって失敗した状態。
Canceled: Taskがキャンセルされた状態。

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

Taskのライフサイクルを理解することで、非同期操作の管理とデバッグが容易になります。

非同期メソッドの設計

非同期メソッドの命名規則

非同期メソッドの命名には、メソッド名の末尾に Async を付けることが一般的です。

これにより、メソッドが非同期であることを明示し、コードの可読性を向上させます。

例えば、データを取得する非同期メソッドはGetDataAsyncと命名します。

public async Task<string> GetDataAsync()
{
    // 非同期メソッドの実装
    return await Task.FromResult("データ");
}

戻り値の型と例外処理

非同期メソッドの戻り値は通常、TaskまたはTask<T>です。

これにより、非同期操作の完了を待機し、結果を取得することができます。

例外処理は、try-catchブロックを使用して非同期メソッド内で行うことができます。

非同期メソッドで発生した例外は、awaitを使用して呼び出し元でキャッチすることも可能です。

public async Task<string> FetchDataAsync()
{
    try
    {
        // 非同期操作の実行
        string data = await Task.Run(() => 
        {
            // データ取得処理
            return "取得したデータ";
        });
        return data;
    }
    catch (Exception ex)
    {
        // 例外処理
        Console.WriteLine($"エラー: {ex.Message}");
        return "エラーが発生しました";
    }
}

非同期メソッドのテスト

非同期メソッドのテストは、通常のメソッドと同様にユニットテストを使用して行います。

非同期メソッドをテストする際は、テストメソッド自体もasyncで定義し、awaitを使用して非同期メソッドを呼び出します。

これにより、非同期操作の結果を正確に検証することができます。

[TestMethod]
public async Task TestFetchDataAsync()
{
    // 非同期メソッドのテスト
    string result = await FetchDataAsync();
    Assert.AreEqual("取得したデータ", result);
}

この例では、FetchDataAsyncメソッドが正しくデータを取得するかどうかをテストしています。

Assert.AreEqualを使用して、期待される結果と実際の結果を比較し、テストの成否を判断します。

非同期メソッドのテストは、非同期処理の正確性を保証するために重要です。

実践的な非同期プログラミング

UIスレッドと非同期処理

UIアプリケーションでは、UIスレッドがユーザーインターフェースの描画やユーザー入力の処理を行います。

非同期処理を使用することで、UIスレッドをブロックせずにバックグラウンドで重い処理を実行できます。

これにより、アプリケーションの応答性が向上します。

public async Task LoadDataAsync()
{
    // UIスレッドをブロックしない非同期処理
    string data = await Task.Run(() => 
    {
        // データのロード処理
        System.Threading.Thread.Sleep(2000); // 2秒待機
        return "ロードされたデータ";
    });
    // UIスレッドでの更新
    UpdateUI(data);
}
private void UpdateUI(string data)
{
    // UIの更新処理
    Console.WriteLine($"UI更新: {data}");
}

非同期ストリームの利用

C# 8.0以降では、非同期ストリームを使用して、非同期にデータを逐次的に処理することができます。

IAsyncEnumerable<T>を使用することで、非同期にデータを生成し、await foreachを使用してデータを消費します。

using System;
public class Program
{
    public static async IAsyncEnumerable<int> GenerateNumbersAsync()
    {
        for (int i = 0; i < 5; i++)
        {
            await Task.Delay(500); // 0.5秒待機
            yield return i;
        }
    }
    public static async Task Main(string[] args)
    {
        await foreach (var number in GenerateNumbersAsync())
        {
            Console.WriteLine($"生成された数: {number}");
        }
    }
}

生成された数: 0
生成された数: 1
生成された数: 2
生成された数: 3
生成された数: 4

この例では、GenerateNumbersAsyncメソッドが非同期に数値を生成し、Mainメソッドでawait foreachを使用して数値を逐次的に処理しています。

非同期処理のキャンセル

非同期処理をキャンセルするには、CancellationTokenを使用します。

CancellationTokenを非同期メソッドに渡し、キャンセルが要求された場合に処理を中断します。

using System;
public class Program
{
    public static async Task PerformCancellableTaskAsync(CancellationToken cancellationToken)
    {
        for (int i = 0; i < 10; i++)
        {
            // キャンセルが要求されたか確認
            cancellationToken.ThrowIfCancellationRequested();

            // 非同期処理
            await Task.Delay(500); // 0.5秒待機
            Console.WriteLine($"処理中: {i}");
        }
    }
    public static async Task Main(string[] args)
    {
        using (var cts = new CancellationTokenSource())
        {
            var task = PerformCancellableTaskAsync(cts.Token);
            // 1秒後にキャンセルを要求
            cts.CancelAfter(1000);
            try
            {
                await task;
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("タスクがキャンセルされました");
            }
        }
    }
}

処理中: 0
処理中: 1
タスクがキャンセルされました

この例では、PerformCancellableTaskAsyncメソッドがキャンセル可能な非同期処理を実行し、Mainメソッドで1秒後にキャンセルを要求しています。

キャンセルが要求されると、OperationCanceledExceptionがスローされ、タスクが中断されます。

応用例

非同期プログラミングでのデータベースアクセス

非同期プログラミングは、データベースアクセスにおいても非常に有用です。

データベースクエリは時間がかかることがあるため、非同期に実行することでアプリケーションの応答性を維持できます。

以下は、Entity Frameworkを使用した非同期データベースアクセスの例です。

public static async Task<List<User>> GetUsersAsync()
{
    using (var context = new UserDbContext())
    {
        // 非同期にデータベースからユーザーを取得
        return await context.Users.ToListAsync();
    }
}
public static async Task Main(string[] args)
{
    var users = await GetUsersAsync();
    Console.WriteLine($"取得したユーザー数: {users.Count}");
}

この例では、GetUsersAsyncメソッドがデータベースからユーザーリストを非同期に取得し、Mainメソッドでその結果を待機して出力しています。

Web API呼び出しの非同期化

Web APIの呼び出しも非同期に行うことで、ネットワーク遅延によるアプリケーションのブロックを防ぐことができます。

HttpClientを使用して非同期にAPIを呼び出す例を示します。

public static async Task<string> FetchApiDataAsync(string url)
{
    using (var client = new HttpClient())
    {
        // 非同期にWeb APIを呼び出し
        HttpResponseMessage response = await client.GetAsync(url);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}
public static async Task Main(string[] args)
{
    string data = await FetchApiDataAsync("https://api.example.com/data");
    Console.WriteLine($"APIから取得したデータ: {data}");
}

この例では、FetchApiDataAsyncメソッドが指定されたURLからデータを非同期に取得し、Mainメソッドでその結果を待機して出力しています。

ファイルI/O操作の非同期化

ファイルの読み書き操作も非同期に行うことで、ディスクI/Oによるアプリケーションのブロックを防ぐことができます。

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

public static async Task<string> ReadFileAsync(string filePath)
{
    using (var reader = new StreamReader(filePath))
    {
        // 非同期にファイルを読み取る
        return await reader.ReadToEndAsync();
    }
}
public static async Task Main(string[] args)
{
    string content = await ReadFileAsync("example.txt");
    Console.WriteLine($"ファイル内容: {content}");
}

この例では、ReadFileAsyncメソッドが指定されたファイルを非同期に読み取り、Mainメソッドでその内容を待機して出力しています。

非同期ファイルI/Oは、特に大きなファイルを扱う際に有効です。