CodeGym /コース /C# SELF /クラス Task と Task<TResult>

クラス Task と Task<TResult>

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

1. はじめに

非同期プログラミングの世界では「フィードバック付きの委譲」という考え方で動いています。例えば、巨大なファイルをダウンロードしたり、ギガバイト単位のログを解析したり、遠いサーバーへリクエストを送る必要があるとします。待ちぼうけして石像のようになる代わりに、システムに「これをやっておいて、終わったら教えてね」と伝え、あなたは他の仕事を続けます。

ここで登場するのが Task です — このアプローチを表すスマートな仲介者のような存在です。単なる技術的抽象ではなく、仕事を実行し、その結果が迷子にならないよう責任を持つ「賢い代理人」です。

Task は個人的なアシスタントのように動き、重要な仕事を任せることができます。うなずいてタスクをノートに書き込み、「あなたは安心して他のことをしてて。終わったらちゃんと知らせるよ」と言ってくれます。そして本当に知らせてくれます — 結果を持って、あるいは何か問題があれば正直に理由を伝えて。

もっと身近な例で言えば、Task はオンラインで予約するシステムに似ています:医者の予約をオンラインで取って確認を受け取れば、長時間待合室で待つ必要はありません。システムが診察時間の近さを知らせてくれて、その間は自分の時間を過ごせます。

クラス Task

Task は .NET の非同期プログラミングの基本ブロックです。将来利用可能になる実行中または将来の操作を表します。メソッドが何も返さないなら、単純に Task を使います。

public async Task BackupToCloudAsync()
{
    // バックアップのマジックをして、何も返さない
}

クラス Task<TResult>

結果(例えば文字列、数値、オブジェクト…)を返す必要があるときは Task<TResult> を使います:

public async Task<string> DownloadHtmlAsync(string url)
{
    // ページをダウンロードしてHTMLを返す
    return "<html>...</html>";
}

なぜ Task で、Thread ではないのか?

Thread はスレッドそのものを管理します(これは重くて危険になりがち)一方、Task はより高レベルの抽象で、スレッドプールで動くこともあれば、I/O 操作のように新しいスレッドを割り当てずに非同期で動くこともあります。低レベルな詳細に頭を悩ませる必要はありません。

Task を使うことで「これを実行したい」と宣言し、実際の実行方法は .NET に任せる、という書き方ができます。

2. Task オブジェクトの構造

知っておくべき Task のプロパティとメソッド

プロパティ / メソッド 説明
Status
タスクの現在の状態
Result
Task<TResult> の結果(スレッドをブロックする)
IsCompleted
タスクが完了しているか
IsFaulted
タスクで例外が発生したか
IsCanceled
タスクがキャンセルされたか
Wait()
完了まで現在のスレッドをブロックする(危険)
ContinueWith()
完了後に別のタスクを起動する
Exception
Task がエラーで終了した場合の例外へのアクセス
Id
タスクの一意の識別子

Task を使う非同期メソッドの動き

sequenceDiagram
    participant Main as Main スレッド
    participant Task as Task (バックグラウンドタスク)
    Main->>Task: Task.Run(() => ...) を起動
    Note right of Task: 背景で実行中
(CPU か I/O) alt タスクが完了した Task->>Main: await が完了して続行 else エラー Task->>Main: await が例外を投げる end

3. タスクの作成と起動: Task はどう動くか

async を使った非同期メソッド

もっとも一般的なのはメソッドを async と宣言して Task か Task<TResult> を返すパターンです(先ほど見たとおり)。

Task.Run:スレッドプールでの実行

重たい処理(大きな数の計算や動画エンコードなど)をバックグラウンドで実行したいときは Task.Run を使えます:

Task work = Task.Run(() =>
{
    // 重い計算 — メインスレッドをブロックしない!
    Console.WriteLine("バックグラウンド計算を開始...");
    Thread.Sleep(2000); // 長い処理のエミュレーション
    Console.WriteLine("バックグラウンド計算が完了!");
});

結果が必要な場合:

Task<int> calculateTask = Task.Run(() =>
{
    // 例えば、最初の100個の和を計算
    int sum = 0;
    for (int i = 1; i <= 100; i++) sum += i;
    return sum;
});

Task.Factory.StartNew

これはより低レベルで柔軟な方法で、スケジューラの指定やパラメータ渡しなど細かい設定が可能です。現代のコードではほとんどの場合 Task.Run を使うことが推奨されます — シンプルで間違いが少ないためです。

4. 今日のアプリ:本のカタログ

例えば、本のカタログアプリがあって、クラウドから本をロードする機能が必要だとします。これは I/O-bound の操作(遅い HTTP リクエストやファイル読み取り)になります。

非同期に本を「ロード」するメソッドを追加します(遅延をエミュレート):

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
}

public class BookCatalog
{
    public List<Book> Books { get; set; } = new();

    public async Task LoadBooksAsync()
    {
        Console.WriteLine("本をロードしています...");
        await Task.Delay(2000); // 長いロードのエミュレーション(例: HTTP またはファイル)
        Books = new List<Book>
        {
            new Book { Title = "CLR via C#", Author = "Jeffrey Richter" },
            new Book { Title = "C# in Depth", Author = "Jon Skeet" }
        };
        Console.WriteLine("本のロードが完了しました。");
    }
}

Main で非同期ロードを呼び出します(await を使って):

var catalog = new BookCatalog();
await catalog.LoadBooksAsync();
Console.WriteLine($"カタログには {catalog.Books.Count} 冊の本があります。");

表:Task を作成・起動する主な方法

作成方法 使い方 結果 用途
async メソッド
async Task / async Task<T>
非同期操作 通常は I/O、使いやすさ
Task.Run
Task.Run(() => { ... })
バックグラウンドタスク CPU-bound(計算)
TaskCompletionSource<T>
手動で Task を作って完了させる プログラマが完全に制御 低レベルな用途では稀に有用

5. Task のライフサイクル

Task はいくつかの状態を持ちます:

  • Created — タスクは作成されたが、起動されていない(明示的に開始する Task の場合)。
  • WaitingToRun — スレッドプールのキューで待機している。
  • Running — 実行中。
  • WaitingForActivation — 起動や外部のアクティベーションを待っている。
  • RanToCompletion — 正常に完了した。
  • Faulted — エラー(例外)で終了した。
  • Canceled — キャンセルされた(キャンセル対応している場合)。

ダイアグラム

flowchart LR
    Start -->|タスク開始| Running
    Running -->|成功| Completed
    Running -->|エラー| Faulted
    Running -->|キャンセル| Canceled

実際に試してみる

Task task = Task.Run(() =>
{
    Thread.Sleep(1000);
});
Console.WriteLine(task.Status); // 通常: Running または WaitingToRun
await task;
Console.WriteLine(task.Status); // 完了後は RanToCompletion

6. Task<TResult> から結果を取得するには?

Task<TResult> は将来得られる結果のラッパーです。結果を待つときは await を使います:

Task<int> sumTask = Task.Run(() =>
{
    int sum = 0;
    for (int i = 1; i <= 5; i++) sum += i;
    return sum;
});

int result = await sumTask;
Console.WriteLine(result); // 15

await を忘れると、結果ではなく Task(約束)を受け取ることになります。よくある「非同期の罠」です。

代替:同期的に結果を取る(UI ではしないこと)

テストなどで await を使えない場合に結果を同期的に取得することがあります。プロパティ .Result を使えます:

int result = sumTask.Result;

しかし Task がまだ完了していないとこのコードはスレッドを ブロック し、UI スレッドならアプリが固まります。なので常に await を優先してください。

Task と Task<TResult> に関する典型的なミス

Task を返さずメソッドが void になってしまう。戻り値がない場合でも Task を返し、void にしないでください。そうしないとエラーを扱えません。

await を無視する。メソッドを呼んで結果を待たずにタスクをそのまま放置すると、タスクは「fire and forget」になり、いつ終わったかや例外が起きたかが分からなくなります。

.Result や .Wait() によるブロッキング待機。UI や ASP.NET でデッドロックしやすいです。基本は await を使いましょう。

7. 高度な機能

タスクのチェーン: ContinueWith

タスク完了後に実行したい処理を ContinueWith でつなげることができます:

Task.Run(() => 10)
    .ContinueWith(t =>
    {
        Console.WriteLine($"完了! 結果: {t.Result}");
    });

ただし現代の C# では async/await を使う方が読みやすいです。

例: 並列と逐次でのデータロード

例えば、別々のソースから2冊の本をロードする必要があるとします。2つの Task を並列に起動して両方を待つことができます:

public async Task LoadBooksFromMultipleSourcesAsync()
{
    Task<List<Book>> t1 = LoadFromCloudAsync();
    Task<List<Book>> t2 = LoadFromLocalAsync();

    // 両方のタスクを並列で待つ
    await Task.WhenAll(t1, t2);

    // 結果を結合
    Books = t1.Result.Concat(t2.Result).ToList();
}

private async Task<List<Book>> LoadFromCloudAsync()
{
    await Task.Delay(2000); // "クラウド"
    return new List<Book> { new Book { Title = "Cloud Book", Author = "Cloud Author" } };
}

private async Task<List<Book>> LoadFromLocalAsync()
{
    await Task.Delay(1000); // "ローカルディスク"
    return new List<Book> { new Book { Title = "Local Book", Author = "Local Author" } };
}

ポイント: await と Task.WhenAll(...) を使うことで、両方のリクエストが同時に開始され(可能なら並列で実行され)、アプリは両方が完了するのを待ちます。

8. 役立つ細かい注意点

Task と Fire-and-forget

ときどきタスクを起動して結果を待たない(例えばログをクラウドに送る、ユーザーが作業している間にトースト通知を出す)ことがあります:

async void LogToCloudAsync(string message)
{
    await Task.Run(() =>
    {
        // 長いログ送信
        Thread.Sleep(1000);
        Console.WriteLine($"ログ送信完了: {message}");
    });
}

しかしこのようなタスクで例外が起きると検出が難しくなります。可能なら Task を返し、少なくとも内部で例外をログするようにしてください。

実務での Task と Task<TResult>

  • クライアントの UWP/WPF/WinForms アプリでは UI をブロックしないように—ファイルやネットワークなどの長い処理は Task を使う。
  • WebAPI/ASP.NET では Task を使うことでネットワーク/DB 待ちにスレッドを使わず、パフォーマンスが向上する。
  • 並列実行を設計して、同時にダウンロード・処理・保存を行う。
  • ほとんどの長い操作には Async バージョンがある:File.ReadAllTextAsync、HttpClient.GetStringAsync など。

FAQ と意外な点

質問: なぜ Task が同期的に実行されることがあるの?
回答: 操作が既に完了している場合(例えば結果がキャッシュされている)、コンパイラやスケジューラは同じスレッドで同期的にメソッドを完了させることがあります。これは正常で、再呼び出しの高速化に寄与します。

質問: なぜ async void を使ってはいけないの?
回答: そのようなメソッドは待機できず、例外をキャッチできず完了を追跡できません。Task を返すようにし、async void は EventHandler(例: Button_Click) のみで使ってください。

質問: 複数のタスクを起動して、そのうち1つだけを待つことはできる?
回答: はい — Task.WhenAny を使ってください。

2
タスク
C# SELF, レベル 60, レッスン 0
ロック未解除
Task を使って結果を返す
Task を使って結果を返す
コメント
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION