MENU
  1. ホーム
  2. C#
  3. C#の非同期プログラミング：タスクキャンセレーションテクニックの完全ガイド

C#の非同期プログラミング：タスクキャンセレーションテクニックの完全ガイド

C#

C#の非同期プログラミングにおいて、タスクのキャンセレーションは非常に重要なテクニックです。非同期操作中にユーザーが操作を中止したり、アプリケーションの状態が変わったりすることはよくあるため、適切なキャンセレーション処理を実装することが求められます。本記事では、C#のタスクキャンセレーションの基本概念から、具体的な実装方法、ベストプラクティスまでを詳しく解説します。

目次

タスクキャンセレーションの基本概念

タスクキャンセレーションとは、実行中の非同期タスクを中止するためのメカニズムです。長時間かかる操作やユーザーの操作に応じて、処理を途中で中断する必要がある場合に有効です。これにより、システムリソースの無駄遣いや不要な処理を防ぐことができます。

CancellationTokenの使い方

CancellationTokenは、タスクキャンセレーションを実現するための基本的なツールです。これを使うことで、タスクにキャンセルリクエストを送信し、そのリクエストをタスク内でチェックすることができます。

CancellationTokenSourceの生成

まず、キャンセル操作を管理するためにCancellationTokenSourceを生成します。これにより、キャンセルリクエストを送信するトークンを取得できます。

CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken token = cts.Token;

タスク内でのキャンセルチェック

非同期タスク内で定期的にtoken.IsCancellationRequestedプロパティをチェックし、キャンセルがリクエストされた場合に適切に処理を中断します。

await Task.Run(() =>
{
    for (int i = 0; i < 100; i++)
    {
        if (token.IsCancellationRequested)
        {
            // キャンセル処理
            break;
        }
        // 他の処理
    }
}, token);

キャンセルリクエストの送信

必要に応じて、CancellationTokenSourceのCancelメソッドを呼び出してキャンセルリクエストを送信します。

cts.Cancel();

タスクのキャンセル処理の実装例

実際のコードを通じて、タスクのキャンセル処理の具体的な実装方法を紹介します。

キャンセル可能なタスクの作成

非同期メソッドにCancellationTokenを渡し、タスク内でキャンセルリクエストをチェックする方法を示します。

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // CancellationTokenSourceを生成
        CancellationTokenSource cts = new CancellationTokenSource();
        CancellationToken token = cts.Token;

        // キャンセル可能なタスクを開始
        Task task = RunAsyncTask(token);

        // 5秒後にタスクをキャンセル
        await Task.Delay(5000);
        cts.Cancel();

        try
        {
            await task;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("タスクがキャンセルされました。");
        }
    }

    static async Task RunAsyncTask(CancellationToken token)
    {
        for (int i = 0; i < 100; i++)
        {
            token.ThrowIfCancellationRequested(); // キャンセルリクエストのチェック

            // 擬似的な長時間処理
            Console.WriteLine($"処理中: {i}");
            await Task.Delay(1000);
        }
    }
}

コードの説明

  1. CancellationTokenSourceを生成し、CancellationTokenを取得します。
  2. 非同期メソッドRunAsyncTaskを呼び出し、タスクを実行します。
  3. 5秒後にcts.Cancel()を呼び出してキャンセルリクエストを送信します。
  4. タスク内でtoken.ThrowIfCancellationRequested()を使ってキャンセルリクエストをチェックし、リクエストがある場合はOperationCanceledExceptionをスローします。
  5. キャンセルが発生すると、OperationCanceledExceptionをキャッチしてキャンセルメッセージを表示します。

この方法により、長時間かかる処理を適切にキャンセルすることができます。

キャンセレーションのタイミングと注意点

タスクのキャンセルを実装する際には、キャンセルのタイミングと注意点を考慮することが重要です。適切なタイミングでキャンセルを行わないと、システムのリソースが無駄に消費されるだけでなく、予期せぬ動作が発生する可能性があります。

キャンセルタイミングの決定

タスクのキャンセルを行うタイミングは、次のような状況に応じて決定されます。

  • ユーザーが操作を中止した場合
  • タスクの進行状況が特定の条件に達した場合
  • システムリソースが不足した場合

注意点

  1. 頻繁なチェックポイントの設定: タスク内で定期的にキャンセルリクエストをチェックすることで、迅速にキャンセルが反映されるようにします。
  2. 一貫したエラーハンドリング: OperationCanceledExceptionを適切にキャッチし、後続の処理が正しく行われるようにします。
  3. リソースのクリーンアップ: タスクがキャンセルされた場合でも、使用したリソース（ファイル、ネットワーク接続など）を正しく解放する必要があります。
  4. ユーザー通知: タスクがキャンセルされたことをユーザーに通知し、適切なフィードバックを提供します。

コード例

以下のコードは、キャンセルタイミングと注意点を考慮した実装例です。

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        CancellationTokenSource cts = new CancellationTokenSource();
        CancellationToken token = cts.Token;

        Task task = PerformOperationAsync(token);

        await Task.Delay(3000);
        cts.Cancel();

        try
        {
            await task;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("タスクがキャンセルされました。");
        }
        finally
        {
            // リソースのクリーンアップ
            Console.WriteLine("リソースを解放しました。");
        }
    }

    static async Task PerformOperationAsync(CancellationToken token)
    {
        for (int i = 0; i < 10; i++)
        {
            token.ThrowIfCancellationRequested(); // キャンセルリクエストのチェック

            // 擬似的な処理
            Console.WriteLine($"処理中: {i}");
            await Task.Delay(1000);
        }
    }
}

非同期メソッドにおけるキャンセレーションの処理

非同期メソッドでのキャンセル処理は、ユーザーやシステムからのキャンセルリクエストに迅速に対応するために重要です。非同期メソッドにCancellationTokenを渡し、適切な箇所でキャンセルリクエストをチェックする方法を解説します。

非同期メソッドの定義

非同期メソッドにおいて、CancellationTokenをパラメータとして受け取ります。これにより、外部からキャンセルリクエストを送信できるようになります。

public async Task ProcessDataAsync(CancellationToken token)
{
    // データ処理の初期化
    Console.WriteLine("データ処理を開始します。");

    // キャンセルリクエストのチェック
    token.ThrowIfCancellationRequested();

    // 非同期データ処理のシミュレーション
    for (int i = 0; i < 10; i++)
    {
        token.ThrowIfCancellationRequested(); // ループ内でも定期的にチェック

        Console.WriteLine($"処理中: {i}");
        await Task.Delay(500); // 擬似的な処理
    }

    // 処理完了
    Console.WriteLine("データ処理が完了しました。");
}

非同期メソッドの呼び出しとキャンセル

非同期メソッドを呼び出す際にCancellationTokenを渡し、必要に応じてキャンセルリクエストを送信します。

public async Task ExecuteAsync()
{
    CancellationTokenSource cts = new CancellationTokenSource();
    CancellationToken token = cts.Token;

    Task processingTask = ProcessDataAsync(token);

    // 任意のタイミングでキャンセルリクエストを送信
    await Task.Delay(2000);
    cts.Cancel();

    try
    {
        await processingTask;
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine("非同期処理がキャンセルされました。");
    }
}

コードの説明

  1. ProcessDataAsyncメソッドは、データ処理を行う非同期メソッドで、CancellationTokenを受け取ります。
  2. メソッド内でtoken.ThrowIfCancellationRequestedを使い、キャンセルリクエストをチェックします。
  3. 外部のExecuteAsyncメソッドでは、CancellationTokenSourceを生成し、非同期メソッドにトークンを渡します。
  4. 必要に応じて、cts.Cancelを呼び出してキャンセルリクエストを送信します。
  5. タスクがキャンセルされた場合、OperationCanceledExceptionをキャッチしてキャンセルメッセージを表示します。

キャンセレーションの応用例

タスクキャンセレーションは、様々なシナリオで応用できます。ここでは、いくつかの実践的な例を紹介します。

データ取得のキャンセレーション

ネットワークからデータを取得する非同期処理において、ユーザーが操作を中止した場合にキャンセルする例です。

public async Task FetchDataAsync(CancellationToken token)
{
    using (HttpClient client = new HttpClient())
    {
        HttpResponseMessage response = await client.GetAsync("https://api.example.com/data", token);
        response.EnsureSuccessStatusCode();

        string data = await response.Content.ReadAsStringAsync();
        Console.WriteLine("データ取得完了: " + data);
    }
}

ファイルダウンロードのキャンセレーション

ファイルをダウンロードするタスクのキャンセル例です。ユーザーがキャンセルボタンを押すことで、ダウンロードを中止します。

public async Task DownloadFileAsync(string url, string filePath, CancellationToken token)
{
    using (HttpClient client = new HttpClient())
    using (HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, token))
    using (Stream streamToReadFrom = await response.Content.ReadAsStreamAsync())
    using (Stream streamToWriteTo = File.Open(filePath, FileMode.Create))
    {
        await streamToReadFrom.CopyToAsync(streamToWriteTo, 81920, token);
        Console.WriteLine("ファイルダウンロード完了: " + filePath);
    }
}

長時間処理のキャンセレーション

データベースのクエリやバッチ処理など、長時間かかる処理のキャンセル例です。システムリソースを効率的に使用するために、必要なタイミングでキャンセルします。

public async Task LongRunningOperationAsync(CancellationToken token)
{
    for (int i = 0; i < 100; i++)
    {
        token.ThrowIfCancellationRequested(); // 定期的にキャンセルリクエストをチェック

        // 擬似的な長時間処理
        Console.WriteLine($"処理中: {i}");
        await Task.Delay(1000, token);
    }
    Console.WriteLine("長時間処理完了");
}

ユーザーインターフェースの応答性向上

UIスレッドをブロックせずに、ユーザーが長時間の操作をキャンセルできるようにすることで、アプリケーションの応答性を向上させる例です。

public async Task PerformUICancellableOperationAsync(CancellationToken token)
{
    // UIスレッドをブロックせずに非同期処理を実行
    await Task.Run(async () =>
    {
        for (int i = 0; i < 10; i++)
        {
            token.ThrowIfCancellationRequested(); // キャンセルリクエストのチェック

            // 擬似的な長時間処理
            Console.WriteLine($"UI処理中: {i}");
            await Task.Delay(1000);
        }
    }, token);
}

これらの例は、タスクキャンセレーションのさまざまな応用方法を示しており、実際のプロジェクトでどのように利用できるかを理解するのに役立ちます。

キャンセレーション処理のベストプラクティス

タスクキャンセレーションを効果的に行うためには、いくつかのベストプラクティスを守ることが重要です。これにより、コードの可読性と保守性を向上させるとともに、予期しない動作を防ぐことができます。

定期的なキャンセルリクエストのチェック

長時間にわたる処理やループ内では、定期的にキャンセルリクエストをチェックすることが重要です。これにより、タスクが迅速にキャンセルされることを保証します。

for (int i = 0; i < 100; i++)
{
    token.ThrowIfCancellationRequested();
    // 長時間処理
    await Task.Delay(1000);
}

キャンセルがスローされた場合のリソースクリーンアップ

キャンセルが発生した場合、未処理のリソース（ファイルハンドル、ネットワーク接続など）を適切にクリーンアップすることが重要です。finallyブロックを使用して、リソース解放を確実に行います。

try
{
    await LongRunningOperationAsync(token);
}
catch (OperationCanceledException)
{
    Console.WriteLine("タスクがキャンセルされました。");
}
finally
{
    // リソースのクリーンアップ
}

ユーザーへのフィードバック

タスクがキャンセルされた際には、ユーザーに適切なフィードバックを提供することが重要です。これにより、ユーザーエクスペリエンスが向上します。

try
{
    await PerformOperationAsync(token);
}
catch (OperationCanceledException)
{
    Console.WriteLine("操作がキャンセルされました。");
    ShowUserCancellationMessage();
}

キャンセレーションのトークン伝播

複数の非同期メソッドを呼び出す場合、同じCancellationTokenを伝播させることで、一貫したキャンセレーションの管理が可能になります。

public async Task ComplexOperationAsync(CancellationToken token)
{
    await Task1Async(token);
    await Task2Async(token);
    await Task3Async(token);
}

キャンセル可能なタスクの連携

複数のキャンセル可能なタスクを連携させる場合、各タスクが適切にキャンセルリクエストをチェックし、必要に応じて早期に終了できるように設計します。

public async Task Task1Async(CancellationToken token)
{
    token.ThrowIfCancellationRequested();
    // タスク1の処理
}

public async Task Task2Async(CancellationToken token)
{
    token.ThrowIfCancellationRequested();
    // タスク2の処理
}

public async Task ExecuteTasksAsync(CancellationToken token)
{
    await Task.WhenAll(Task1Async(token), Task2Async(token));
}

これらのベストプラクティスを実践することで、C#における非同期プログラミングのキャンセレーションをより効果的に管理し、信頼性の高いコードを作成することができます。

トラブルシューティングとよくある問題

タスクキャンセレーションを実装する際に直面する可能性のあるトラブルとその解決方法について説明します。

キャンセルが機能しない場合

キャンセルが期待通りに動作しない場合、以下の点を確認してください。

  • CancellationTokenが正しく渡されているか。
  • タスク内でtoken.ThrowIfCancellationRequestedが適切な頻度で呼ばれているか。
  • CancellationTokenSourceのCancelメソッドが呼び出されているか。
if (!token.IsCancellationRequested)
{
    // キャンセルリクエストがまだ来ていない場合の処理
}
else
{
    // キャンセルリクエストが来た場合の処理
}

OperationCanceledExceptionの取り扱い

OperationCanceledExceptionが適切にキャッチされていない場合、アプリケーションが予期しない動作をする可能性があります。この例外を正しくキャッチし、キャンセルされたタスクの後処理を行います。

try
{
    await SomeLongRunningTask(token);
}
catch (OperationCanceledException)
{
    Console.WriteLine("タスクがキャンセルされました。");
}

リソースのリーク

キャンセルされたタスクがリソースを解放しない場合、リソースリークが発生する可能性があります。finallyブロックを使って、キャンセル後も必ずリソースを解放するようにします。

try
{
    await SomeResourceIntensiveTask(token);
}
catch (OperationCanceledException)
{
    Console.WriteLine("タスクがキャンセルされました。");
}
finally
{
    // リソースのクリーンアップ
}

キャンセルタイミングの問題

キャンセルリクエストが送信されても、タスクがすぐに中止されない場合があります。これは、タスクが長時間にわたる操作を行っており、キャンセルチェックが適切な頻度で行われていないことが原因です。頻繁にtoken.ThrowIfCancellationRequestedをチェックするようにします。

for (int i = 0; i < 1000; i++)
{
    token.ThrowIfCancellationRequested();
    // 長時間処理
    await Task.Delay(100);
}

キャンセレーションの競合

複数のキャンセルリクエストが同時に送信されると、予期しない動作が発生することがあります。このような場合は、適切なロック機構を使ってキャンセルリクエストの処理を同期化します。

lock (cancelLock)
{
    if (!token.IsCancellationRequested)
    {
        cts.Cancel();
    }
}

これらのトラブルシューティングのポイントを押さえておくことで、タスクキャンセレーションの実装における問題を迅速に解決し、信頼性の高いコードを作成することができます。

演習問題

タスクキャンセレーションに関する理解を深めるために、いくつかの演習問題を提供します。これらの問題を解くことで、実践的なスキルを身につけることができます。

問題1: 基本的なキャンセル処理の実装

以下の非同期メソッドにキャンセル処理を追加してください。

public async Task SimpleOperationAsync()
{
    for (int i = 0; i < 10; i++)
    {
        // 擬似的な処理
        Console.WriteLine($"処理中: {i}");
        await Task.Delay(1000);
    }
}

ヒント: CancellationTokenをパラメータとして追加し、キャンセルリクエストをチェックするコードを挿入します。

問題2: ファイルダウンロードのキャンセル処理

ファイルダウンロード処理をキャンセル可能にしてください。

public async Task DownloadFileAsync(string url, string filePath)
{
    using (HttpClient client = new HttpClient())
    using (HttpResponseMessage response = await client.GetAsync(url))
    using (Stream streamToReadFrom = await response.Content.ReadAsStreamAsync())
    using (Stream streamToWriteTo = File.Open(filePath, FileMode.Create))
    {
        await streamToReadFrom.CopyToAsync(streamToWriteTo);
        Console.WriteLine("ファイルダウンロード完了: " + filePath);
    }
}

ヒント: HttpClient.GetAsyncおよびCopyToAsyncメソッドにCancellationTokenを渡します。

問題3: 長時間処理のキャンセル

以下の長時間処理にキャンセル機能を追加してください。

public async Task LongRunningTaskAsync()
{
    for (int i = 0; i < 100; i++)
    {
        // 擬似的な長時間処理
        Console.WriteLine($"処理中: {i}");
        await Task.Delay(1000);
    }
}

ヒント: ループ内で定期的にCancellationToken.ThrowIfCancellationRequestedを呼び出します。

問題4: 非同期メソッドの連携

複数の非同期メソッドをキャンセル可能に連携させてください。

public async Task Operation1Async()
{
    // 擬似的な処理
    await Task.Delay(3000);
}

public async Task Operation2Async()
{
    // 擬似的な処理
    await Task.Delay(3000);
}

public async Task ExecuteOperationsAsync()
{
    await Operation1Async();
    await Operation2Async();
}

ヒント: 各メソッドにCancellationTokenを追加し、ExecuteOperationsAsyncメソッドでトークンを伝播させます。

これらの演習問題を通じて、タスクキャンセレーションの実践的なスキルを磨いてください。

まとめ

C#におけるタスクキャンセレーションは、非同期プログラミングで非常に重要なテクニックです。この記事では、タスクキャンセレーションの基本概念から具体的な実装方法、ベストプラクティス、トラブルシューティング、そして応用例までを詳しく解説しました。適切なキャンセル処理を実装することで、システムリソースの無駄遣いを防ぎ、ユーザーエクスペリエンスを向上させることができます。演習問題を通じて、実践的なスキルを磨き、より信頼性の高い非同期プログラミングを実現してください。

C#
非同期プログラミング C# CancellationToken タスクキャンセレーション

コメント

コメントする

目次