CodeGym /コース /C# SELF /非同期データストリーム

非同期データストリーム

C# SELF
レベル 62, レッスン 0
使用可能

1. はじめに

あなたはすでに async と await に馴染みがあるでしょう。単発の非同期操作、例えば1つのファイルのダウンロードには十分だけど、データがストリーム状に到着する場合や、リソースが非同期でのクリーンアップを必要とする場合はどうするか?

非同期「コレクション」の問題: データベースから数百万件のレコードを取得する必要があると想像してみてください。もしメソッドが Task<List<T>> を返すなら、メモリにすべてのデータが読み込まれるまで待つことになります。これは非効率でレイテンシーを生みます。各要素を非同期に取得する必要がある場合、同期的な IEnumerable<T> も適しません。

非同期リソース解放の問題: IDisposable と using は同期的なクリーンアップには有効です。でも、ネットワーク接続のクローズやバッファのフラッシュが非同期である場合はどうする?同期的な Dispose() の内部で await は使えないため、スレッドのブロックや不完全なクリーンアップにつながります。

これらの問題を解決するために IAsyncEnumerable<T> と IAsyncDisposable が導入されました。

2. 非同期データストリーム

IAsyncEnumerable<T> は IEnumerable<T> の非同期版です。これにより、すべてのデータが揃うのを待たずに、順に要素を非同期に生成できるようになります。

どんなときに使うか?

  • 大きなファイルを行単位で非同期に読む: 例えばギガバイト級のログファイル。
  • ネットワークやデータベースからのストリーミング: APIの結果が部分的に届く場合。
  • サーバーのストリーミングAPIの実装: 例えば gRPC Streaming。
  • データが非同期に生成または到着し、段階的に処理する必要があるあらゆるケース。

仕組み

  1. IAsyncEnumerable<T>: GetAsyncEnumerator(CancellationToken cancellationToken) メソッドを持つインターフェース。キャンセルトークンは重要!
  2. IAsyncEnumerator<T>: ValueTask<bool> を返す MoveNextAsync()(次へ進む)と Current(現在の要素)を持つインターフェース。さらに IAsyncDisposable を継承しています。
  3. await foreach: IAsyncEnumerable<T> を簡単に反復できます。コンパイラが自動的に MoveNextAsync() と Current を呼び出します。重要なのは、await foreach がイテレータの DisposeAsync() を反復終了後(例外時も含め)必ず呼ぶことを保証する点です。

IAsyncEnumerable<T> を async yield return で作る

async メソッド内で yield return を使い、IAsyncEnumerable<T> を返すことができます。これにより 非同期ジェネレータ を作れます。メソッド内で await を使って生成を一時停止し、非同期操作の完了を待ってから再開できます。

例: シンプルな非同期ジェネレータ


async IAsyncEnumerable<int> GenerateNumbersAsync()
{
    for (int i = 0; i < 3; i++)
    {
        Console.WriteLine($"ジェネレート中: {i}");
        await Task.Delay(100); // 非同期処理のシミュレーション
        yield return i; 
    }
}

// 利用例:
async Task ConsumeAsyncNumbers()
{
    await foreach (var number in GenerateNumbersAsync())
    {
        Console.WriteLine($"受信: {number}");
    }
}
// 呼び出し: await ConsumeAsyncNumbers();

例: ファイルを行単位で非同期に読む


async IAsyncEnumerable<string> ReadFileLinesAsync(string filePath)
{
    using var reader = new StreamReader(filePath); // ここでの 'using' (StreamReader は IAsyncDisposable を実装)
    string? line;
    while ((line = await reader.ReadLineAsync()) != null) 
    {
        yield return line;
    }
}

// 利用例:
async Task ProcessFileAsync()
{
    await File.WriteAllLinesAsync("data.txt", new[] { "ストリング 1", "ストリング 2", "ストリング 3" });
    await foreach (var line in ReadFileLinesAsync("data.txt")) 
    {
        Console.WriteLine($"処理済み行: {line}");
    }
}
// 呼び出し: await ProcessFileAsync();

例: キャンセル可能な非同期ジェネレータ (CancellationToken)


async IAsyncEnumerable<int> GetCancelableSequence(
    [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken token = default)
{
    for (int i = 0; i < 10; i++)
    {
        token.ThrowIfCancellationRequested(); // キャンセルをチェック
        await Task.Delay(200, token); // Task.Delay も token によるキャンセルをサポート
        yield return i;
    }
}

// 利用例:
async Task ConsumeAndCancel()
{
    var cts = new CancellationTokenSource(500); // 500ms でキャンセル
    try
    {
        await foreach (var num in GetCancelableSequence(cts.Token))
        {
            Console.WriteLine($"受信: {num}");
        }
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine("生成がキャンセルされました!");
    }
}
// 呼び出し: await ConsumeAndCancel();

[EnumeratorCancellation] 属性は、CancellationToken を非同期ジェネレータに渡せるようにします。これにより、呼び出し側が CancellationTokenSource を使ってキャンセルを要求したときにイテレーションを中止できます。この属性がないと、トークンは自動的に GetAsyncEnumerator に渡されません。

3. 非同期リソース管理

同期的な IDisposable の問題

IDisposable の Dispose() は同期的(void Dispose())です。そこでは await を使えません。データベース接続のクローズやファイルへのバッファ書き込みが時間のかかる非同期操作だと、同期的な Dispose() がスレッドをブロックし、非同期アプリケーションでは問題になります。

解決策: IAsyncDisposable

IAsyncDisposable はこの問題を解決します。唯一のメソッドは: ValueTask DisposeAsync() — 非同期でのクリーンアップ用メソッドです。

await using

これは using の非同期版で、IAsyncDisposable を実装するオブジェクト向けです。

  • await using は、リソースが宣言されたブロックの終了時(例外による抜けも含む)に DisposeAsync() が呼ばれることを保証します。
  • 非同期にリソースを正しく解放でき、ブロッキングを避けられます。

例: 基本的な IAsyncDisposable と await using


class MyAsyncResource : IAsyncDisposable
{
    public MyAsyncResource() => Console.WriteLine("リソースをオープンしました。");
    
    public async ValueTask DisposeAsync()
    {
        Console.WriteLine("非同期クリーンアップを開始します...");
        await Task.Delay(200); // 非同期クリーンアップのシミュレーション
        Console.WriteLine("非同期クリーンアップ完了。");
    }
}

// await using の利用
async Task UseAndDisposeResource()
{
    await using var resource = new MyAsyncResource(); 
    Console.WriteLine("リソースを使用中...");
} // ここで自動的に resource.DisposeAsync() が呼ばれる

// 呼び出し: await UseAndDisposeResource();

例: 複数の await using ブロック


async Task UseMultipleResources()
{
    await using var res1 = new MyAsyncResource();
    await using var res2 = new MyAsyncResource();
    Console.WriteLine("両方のリソースを使用しています...");
} // リソースは LIFO (Last In, First Out) の順で解放されます: まず res2.DisposeAsync()、次に res1.DisposeAsync() が呼ばれます。
// 呼び出し: await UseMultipleResources();

IAsyncEnumerable<T> と IAsyncDisposable の互換性

重要なのは: IAsyncEnumerator<T>(await foreach が使うもの)は自身が IAsyncDisposable を継承していることです。つまり、非同期ジェネレータが(上の例の StreamReader のような)非同期で解放されるリソースを使っている場合、await foreach がそれを処理して、イテレータの DisposeAsync() をイテレーション終了時に呼びます。

2
タスク
C# SELF, レベル 62, レッスン 0
ロック未解除
非同期ファイル読み込み
非同期ファイル読み込み
コメント
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION