C# BackgroundWorkerの使い方を初心者向けに解説｜UIが固まらない非同期処理・進捗表示・キャンセル対応まで

はじめに

C#でWindows Formsアプリを作っていると、「ボタンを押した瞬間に画面が固まる」「ProgressBarが更新されない」「キャンセルボタンを押しても反応しない」といった問題に出会うことがあります。

この原因の多くは、時間のかかる処理をUIスレッドで直接実行していることです。UIスレッドは、ボタンのクリック、画面の再描画、ラベルの更新などを担当しています。そのため、同じスレッドで重い処理を実行すると、画面操作や再描画が止まったように見えてしまいます。

そこで使えるのがBackgroundWorkerです。BackgroundWorkerを使うと、時間のかかる処理をUIスレッドとは別のスレッドで実行し、処理中の進捗表示や完了後のUI更新、キャンセル処理を比較的わかりやすく実装できます。Microsoft Learnでも、BackgroundWorkerは時間のかかる処理を別スレッドで実行し、UIの応答性を保つためのクラスとして説明されています。

この記事では、C#のBackgroundWorkerの基本から、非同期処理、進捗表示、キャンセル、引数と戻り値、例外処理、よくあるエラー、実践的なサンプルコードまで初心者向けに解説します。

1. C#のBackgroundWorkerとは？UIが固まる原因と解決できること

1-1. BackgroundWorkerの役割を初心者向けにわかりやすく解説

BackgroundWorkerは、C#でバックグラウンド処理を実行するためのクラスです。主にWindows Formsアプリで使われ、時間のかかる処理を画面とは別のスレッドで動かすために利用されます。

たとえば、次のような処理は時間がかかることがあります。

• 大量データの読み込み

• ファイルのコピー

• 画像変換

• CSVやExcelファイルの解析

• データベース処理

• 外部APIとの通信

• 重い計算処理

これらをボタンクリックイベントの中で直接実行すると、処理が終わるまで画面が反応しなくなる場合があります。BackgroundWorkerを使うと、重い処理をDoWorkイベントで実行し、画面更新はProgressChangedやRunWorkerCompletedで行う、という役割分担ができます。

1-2. UIスレッドで重い処理を実行すると画面が固まる理由

Windows Formsの画面は、基本的にUIスレッドと呼ばれる1つのスレッドで操作されます。このUIスレッドは、次のような処理を担当しています。

このUIスレッド上でforループやThread.Sleep、ファイル処理などの重い処理を実行すると、その間は画面の再描画やクリックイベントを処理できません。その結果、ユーザーから見ると「アプリが固まった」「応答なしになった」と感じます。

悪い例は次のようなコードです。

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    labelStatus.Text = "処理中...";

    for (int i = 0; i < 10; i++)
    {
        Thread.Sleep(1000); // 重い処理の代わり
    }

    labelStatus.Text = "完了しました";
}

このコードでは、buttonStart_ClickがUIスレッド上で実行されます。Thread.Sleepで止まっている間、画面は更新されず、ボタンも反応しにくくなります。

1-3. BackgroundWorkerでできること：非同期処理・進捗表示・完了通知・キャンセル

BackgroundWorkerでは、主に次のことができます。

BackgroundWorkerでは、バックグラウンド処理を開始するためにRunWorkerAsyncを呼び出し、処理完了時にはRunWorkerCompletedイベントが発生します。公式ドキュメントでも、この流れが基本的な使い方として説明されています。

1-4. WinFormsアプリでBackgroundWorkerが使われる代表的な場面

BackgroundWorkerは、特にWindows Formsアプリで次のような場面に向いています。

初心者にとっては、DoWork、ProgressChanged、RunWorkerCompletedという3つのイベントに処理を分けられるため、非同期処理の流れを理解しやすい点がメリットです。

1-5. Task／async-awaitとの違いと、今でもBackgroundWorkerを使うケース

現在のC#では、非同期処理にはTaskやasync-awaitを使うことが一般的です。特に、Web API呼び出し、ファイル読み込み、データベースアクセスなどのI/O処理ではasync-awaitの方が自然に書けます。

一方、BackgroundWorkerはイベントベースで非同期処理を扱う古くからある仕組みです。新規開発ではTaskやasync-awaitを検討することが多いですが、次のようなケースでは今でもBackgroundWorkerが使われます。

Microsoft Learnでは、BackgroundWorkerは.NET 10.0向けAPIとしても掲載されており、Windows Formsのバックグラウンド処理の説明にも使われています。ただし、現代的なC#の非同期処理ではasync-awaitも重要な選択肢です。

2. BackgroundWorkerを使う前に押さえる基本構成

2-1. BackgroundWorkerの主要プロパティ一覧

BackgroundWorkerを使う前に、まず主要なプロパティを押さえておきましょう。

特に重要なのは、WorkerReportsProgressとWorkerSupportsCancellationです。進捗表示を使うならWorkerReportsProgress = true、キャンセルを使うならWorkerSupportsCancellation = trueを設定します。

C#
backgroundWorker1.WorkerReportsProgress = true;
backgroundWorker1.WorkerSupportsCancellation = true;

WorkerReportsProgressがfalseのままReportProgressを呼ぶと例外が発生します。公式ドキュメントでも、ReportProgressを使うにはWorkerReportsProgressをtrueにする必要があると説明されています。

2-2. DoWork・ProgressChanged・RunWorkerCompletedの役割

BackgroundWorkerで特に重要なのは、次の3つのイベントです。

役割を簡単に分けると、次のようになります。

DoWork
  → 重い処理を書く場所

ProgressChanged
  → 処理中の進捗を画面に表示する場所

RunWorkerCompleted
  → 処理完了後に画面を元に戻す場所

重要なのは、DoWorkではUIコントロールを直接操作しないことです。DoWorkはUIスレッドとは別のスレッドで実行されるため、labelStatus.Text = "処理中";のような画面操作を直接書くとエラーの原因になります。

2-3. RunWorkerAsyncでバックグラウンド処理を開始する流れ

BackgroundWorkerの処理は、RunWorkerAsyncを呼び出すことで開始します。

C#
backgroundWorker1.RunWorkerAsync();

基本的な流れは次のとおりです。

1. ボタンをクリックする
2. RunWorkerAsyncを呼ぶ
3. DoWorkイベントが実行される
4. 必要に応じてReportProgressで進捗を通知する
5. ProgressChangedで画面を更新する
6. 処理が終わる
7. RunWorkerCompletedで完了後の画面を更新する

引数を渡したい場合は、RunWorkerAsyncに値を指定します。

C#
backgroundWorker1.RunWorkerAsync(100);

渡した引数は、DoWorkイベント内でe.Argumentから取得できます。

C#
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    int count = (int)e.Argument;
}

2-4. WorkerReportsProgressとWorkerSupportsCancellationの設定

進捗表示とキャンセル処理を使う場合は、初期設定で次のように書きます。

C#
backgroundWorker1.WorkerReportsProgress = true;
backgroundWorker1.WorkerSupportsCancellation = true;

それぞれの意味は次のとおりです。

設定し忘れると、進捗表示が呼ばれなかったり、キャンセルできなかったりします。

2-5. UIを直接更新してはいけない理由

Windows Formsのコントロールは、基本的に作成されたUIスレッドから操作する必要があります。DoWorkは別スレッドで実行されるため、次のようなコードは避けます。

C#
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    // NG：DoWork内でUIを直接更新している
    labelStatus.Text = "処理中...";
}

正しくは、ReportProgressでUIスレッド側に通知し、ProgressChangedで画面を更新します。

C#
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    BackgroundWorker worker = (BackgroundWorker)sender;
    worker.ReportProgress(50, "半分完了しました");
}

private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    labelStatus.Text = e.UserState?.ToString();
}

ReportProgressによって発生するProgressChangedイベントは、BackgroundWorkerを作成した側のスレッドで実行されるため、UI更新に使いやすい仕組みになっています。

3. C# BackgroundWorkerの基本的な使い方

3-1. BackgroundWorkerをフォームに追加する方法

Visual StudioのWindows Formsデザイナーを使っている場合、BackgroundWorkerはツールボックスからフォームに追加できます。

手順は次のとおりです。

1. Windows Formsのフォームを開く

2. ツールボックスを表示する

3. 「コンポーネント」からBackgroundWorkerを探す

4. フォームにドラッグ＆ドロップする

5. 画面下部のコンポーネントトレイにbackgroundWorker1が表示される

6. プロパティからWorkerReportsProgressやWorkerSupportsCancellationを設定する

7. イベント一覧からDoWorkなどを追加する

デザイナーで追加すると、自動的にbackgroundWorker1という名前のコンポーネントが作成されます。

3-2. コードでBackgroundWorkerを生成する方法

デザイナーを使わず、コードだけで作成することもできます。

C#
using System.ComponentModel;

private BackgroundWorker worker = new BackgroundWorker();

public Form1()
{
    InitializeComponent();

    worker.WorkerReportsProgress = true;
    worker.WorkerSupportsCancellation = true;

    worker.DoWork += Worker_DoWork;
    worker.ProgressChanged += Worker_ProgressChanged;
    worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
}

イベントハンドラーは次のように用意します。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
}

private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
}

private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
}

3-3. DoWorkイベントに重い処理を書く

DoWorkには、時間のかかる処理を書きます。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    for (int i = 0; i < 10; i++)
    {
        Thread.Sleep(500); // 重い処理の代わり
    }
}

実際のアプリでは、Thread.Sleepの部分がファイル処理、データベース処理、計算処理などになります。

3-4. ボタンクリックでRunWorkerAsyncを呼び出す

開始ボタンを押したときに、RunWorkerAsyncを呼び出します。

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    worker.RunWorkerAsync();
}

ただし、すでに実行中の状態で再度RunWorkerAsyncを呼ぶとエラーになります。そのため、通常はIsBusyを確認します。

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    if (!worker.IsBusy)
    {
        worker.RunWorkerAsync();
    }
}

3-5. RunWorkerCompletedで処理完了後のUIを更新する

処理が終わった後の画面更新は、RunWorkerCompletedに書きます。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    labelStatus.Text = "完了しました";
    buttonStart.Enabled = true;
}

RunWorkerCompletedでは、成功、キャンセル、エラーを分けて処理できます。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
    }
    else if (e.Error != null)
    {
        labelStatus.Text = "エラーが発生しました";
    }
    else
    {
        labelStatus.Text = "完了しました";
    }

    buttonStart.Enabled = true;
}

3-6. 最小構成のサンプルコード

最小限のBackgroundWorkerサンプルは次のとおりです。

C#
using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;

public partial class Form1 : Form
{
    private BackgroundWorker worker = new BackgroundWorker();

    public Form1()
    {
        InitializeComponent();

        worker.DoWork += Worker_DoWork;
        worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
    }

    private void buttonStart_Click(object sender, EventArgs e)
    {
        if (worker.IsBusy)
        {
            return;
        }

        labelStatus.Text = "処理中...";
        buttonStart.Enabled = false;

        worker.RunWorkerAsync();
    }

    private void Worker_DoWork(object sender, DoWorkEventArgs e)
    {
        // 重い処理の代わり
        Thread.Sleep(3000);
    }

    private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        buttonStart.Enabled = true;
        labelStatus.Text = "完了しました";
    }
}

このコードでは、ボタンを押すと3秒間の処理がバックグラウンドで実行されます。その間もUIスレッドは止まらないため、画面が固まりにくくなります。

4. UIが固まらない非同期処理の実装例

4-1. 悪い例：ボタンクリック内で重い処理を直接実行するコード

まず、UIが固まる悪い例を見てみましょう。

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    labelStatus.Text = "処理中...";
    progressBar1.Value = 0;

    for (int i = 1; i <= 10; i++)
    {
        Thread.Sleep(500);
        progressBar1.Value = i * 10;
    }

    labelStatus.Text = "完了しました";
}

このコードは一見問題なさそうに見えます。しかし、buttonStart_Clickの中で重い処理を直接実行しているため、画面が固まる原因になります。

特に次のような問題が起こります。

4-2. 良い例：BackgroundWorkerで重い処理を別スレッドに分離するコード

BackgroundWorkerを使うと、重い処理をDoWorkに移せます。

C#
private BackgroundWorker worker = new BackgroundWorker();

public Form1()
{
    InitializeComponent();

    worker.DoWork += Worker_DoWork;
    worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
}

private void buttonStart_Click(object sender, EventArgs e)
{
    if (worker.IsBusy)
    {
        return;
    }

    labelStatus.Text = "処理中...";
    buttonStart.Enabled = false;

    worker.RunWorkerAsync();
}

private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    for (int i = 1; i <= 10; i++)
    {
        Thread.Sleep(500);
    }
}

private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    labelStatus.Text = "完了しました";
    buttonStart.Enabled = true;
}

このようにすると、重い処理はバックグラウンドで動き、UIスレッドは画面操作を受け付けられます。

4-3. 処理中にボタンを無効化して二重実行を防ぐ

バックグラウンド処理中に開始ボタンを何度も押されると、二重実行の原因になります。そのため、処理開始時にボタンを無効化します。

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    if (worker.IsBusy)
    {
        MessageBox.Show("すでに処理中です。");
        return;
    }

    buttonStart.Enabled = false;
    labelStatus.Text = "処理中...";

    worker.RunWorkerAsync();
}

処理完了後にボタンを有効化します。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    buttonStart.Enabled = true;
    labelStatus.Text = "完了しました";
}

4-4. IsBusyで実行中かどうかを判定する

IsBusyは、BackgroundWorkerが実行中かどうかを示します。

C#
if (worker.IsBusy)
{
    return;
}

開始処理では、基本的にIsBusyを確認してからRunWorkerAsyncを呼び出します。

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    if (!worker.IsBusy)
    {
        worker.RunWorkerAsync();
    }
}

これにより、実行中のBackgroundWorkerに対して再度RunWorkerAsyncを呼んでしまうミスを防げます。

4-5. 処理完了後にボタンやラベルを元に戻す

処理中に変更したUIは、完了時に必ず元に戻します。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    buttonStart.Enabled = true;
    buttonCancel.Enabled = false;

    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
    }
    else if (e.Error != null)
    {
        labelStatus.Text = "エラーが発生しました";
    }
    else
    {
        labelStatus.Text = "完了しました";
    }
}

完了時にUIを復旧する処理をまとめておくと、通常完了、キャンセル、エラーのいずれの場合でも画面が中途半端な状態になりにくくなります。

5. ProgressBarで進捗表示を行う方法

5-1. ReportProgressで進捗率を通知する

進捗表示を行うには、まずWorkerReportsProgressをtrueにします。

C#
worker.WorkerReportsProgress = true;

次に、DoWork内でReportProgressを呼び出します。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    BackgroundWorker bw = (BackgroundWorker)sender;

    for (int i = 1; i <= 100; i++)
    {
        Thread.Sleep(50);
        bw.ReportProgress(i);
    }
}

ReportProgressを呼ぶと、ProgressChangedイベントが発生します。進捗率はe.ProgressPercentageで受け取れます。

5-2. ProgressChangedでProgressBarとLabelを更新する

ProgressBarやLabelの更新はProgressChangedで行います。

C#
private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progressBar1.Value = e.ProgressPercentage;
    labelStatus.Text = $"{e.ProgressPercentage}% 完了";
}

ProgressChangedはUI更新用のイベントとして使えるため、ProgressBarやLabelの更新を書く場所として適しています。

5-3. 0〜100％の進捗率を計算する考え方

ReportProgressに渡す値は、通常0〜100の整数で表します。

たとえば、100件のデータを処理する場合は次のように計算します。

C#
int percent = (i + 1) * 100 / totalCount;
worker.ReportProgress(percent);

全体件数がtotalCount、現在処理した件数がi + 1なら、進捗率は次の式で求められます。

進捗率 = 処理済み件数 × 100 / 全体件数

コード例は次のとおりです。

C#
int totalCount = 50;

for (int i = 0; i < totalCount; i++)
{
    Thread.Sleep(100);

    int percent = (i + 1) * 100 / totalCount;
    worker.ReportProgress(percent);
}

5-4. UserStateを使ってメッセージや処理状況を渡す

ReportProgressには、進捗率だけでなく任意のオブジェクトも渡せます。

C#
worker.ReportProgress(percent, "ファイルを読み込み中...");

この第2引数は、ProgressChanged側でe.UserStateとして受け取れます。

C#
private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progressBar1.Value = e.ProgressPercentage;
    labelStatus.Text = e.UserState?.ToString();
}

UserStateを使うと、次のような情報をUIに渡せます。

ReportProgress(Int32, Object)では、進捗率に加えて任意の状態情報を渡せます。公式ドキュメントでも、userStateはProgressChangedEventArgs.UserStateとして返される値として説明されています。

5-5. 進捗表示付きのサンプルコード

進捗表示付きの基本サンプルです。

C#
using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;

public partial class Form1 : Form
{
    private BackgroundWorker worker = new BackgroundWorker();

    public Form1()
    {
        InitializeComponent();

        worker.WorkerReportsProgress = true;

        worker.DoWork += Worker_DoWork;
        worker.ProgressChanged += Worker_ProgressChanged;
        worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
    }

    private void buttonStart_Click(object sender, EventArgs e)
    {
        if (worker.IsBusy)
        {
            return;
        }

        progressBar1.Value = 0;
        labelStatus.Text = "開始しました";
        buttonStart.Enabled = false;

        worker.RunWorkerAsync();
    }

    private void Worker_DoWork(object sender, DoWorkEventArgs e)
    {
        BackgroundWorker bw = (BackgroundWorker)sender;

        int total = 20;

        for (int i = 0; i < total; i++)
        {
            Thread.Sleep(200);

            int percent = (i + 1) * 100 / total;
            bw.ReportProgress(percent, $"{i + 1} / {total} 件を処理しました");
        }
    }

    private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        progressBar1.Value = e.ProgressPercentage;
        labelStatus.Text = e.UserState?.ToString();
    }

    private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        buttonStart.Enabled = true;
        labelStatus.Text = "完了しました";
    }
}

このコードでは、処理件数に応じてProgressBarとLabelが更新されます。

5-6. 進捗が不明な処理でマーキースタイルを使う方法

処理の全体件数がわからない場合、0〜100%の進捗率を計算できません。たとえば、外部APIの応答待ちや、終了時間が予測できない処理では進捗率が不明なことがあります。

その場合は、ProgressBarのStyleをMarqueeにします。

C#
progressBar1.Style = ProgressBarStyle.Marquee;
progressBar1.MarqueeAnimationSpeed = 30;

処理完了後は通常表示に戻します。

C#
progressBar1.Style = ProgressBarStyle.Blocks;
progressBar1.MarqueeAnimationSpeed = 0;
progressBar1.Value = 0;

使用例です。

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    if (worker.IsBusy)
    {
        return;
    }

    progressBar1.Style = ProgressBarStyle.Marquee;
    progressBar1.MarqueeAnimationSpeed = 30;
    labelStatus.Text = "処理中...";

    worker.RunWorkerAsync();
}

private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    progressBar1.Style = ProgressBarStyle.Blocks;
    progressBar1.MarqueeAnimationSpeed = 0;
    progressBar1.Value = 0;

    labelStatus.Text = "完了しました";
}

6. キャンセル処理を実装する方法

6-1. CancelAsyncでキャンセル要求を出す

BackgroundWorkerでキャンセル処理を使うには、まずWorkerSupportsCancellationをtrueにします。

C#
worker.WorkerSupportsCancellation = true;

キャンセルボタンではCancelAsyncを呼び出します。

C#
private void buttonCancel_Click(object sender, EventArgs e)
{
    if (worker.IsBusy)
    {
        worker.CancelAsync();
        labelStatus.Text = "キャンセル要求中...";
    }
}

ここで注意したいのは、CancelAsyncを呼んだからといって即座に処理が強制停止されるわけではないことです。CancelAsyncは「キャンセルしてほしい」という要求を出すだけです。

6-2. CancellationPendingでキャンセル要求を確認する

実際に処理を止めるには、DoWork内でCancellationPendingを定期的に確認します。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    BackgroundWorker bw = (BackgroundWorker)sender;

    for (int i = 0; i < 100; i++)
    {
        if (bw.CancellationPending)
        {
            e.Cancel = true;
            return;
        }

        Thread.Sleep(100);
    }
}

長いループ処理では、毎回または一定間隔でCancellationPendingを確認するのが基本です。

6-3. e.Cancelをtrueにしてキャンセル完了を通知する

キャンセル要求を検知したら、e.Cancel = true;を設定してDoWorkを抜けます。

C#
if (bw.CancellationPending)
{
    e.Cancel = true;
    return;
}

これにより、RunWorkerCompletedでe.Cancelledがtrueになります。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
    }
}

6-4. RunWorkerCompletedで通常完了・キャンセル・エラーを分岐する

RunWorkerCompletedでは、次の順番で確認するのが安全です。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
    }
    else if (e.Error != null)
    {
        labelStatus.Text = "エラーが発生しました";
        MessageBox.Show(e.Error.Message);
    }
    else
    {
        labelStatus.Text = "正常に完了しました";
    }

    buttonStart.Enabled = true;
    buttonCancel.Enabled = false;
}

Resultを使う場合は、ErrorやCancelledを確認してからアクセスする必要があります。公式ドキュメントでも、Errorがある場合やキャンセル済みの場合にResultへアクセスすると例外につながるため、先にErrorとCancelledを確認するよう説明されています。

6-5. キャンセルボタン付きのサンプルコード

C#
using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;

public partial class Form1 : Form
{
    private BackgroundWorker worker = new BackgroundWorker();

    public Form1()
    {
        InitializeComponent();

        worker.WorkerReportsProgress = true;
        worker.WorkerSupportsCancellation = true;

        worker.DoWork += Worker_DoWork;
        worker.ProgressChanged += Worker_ProgressChanged;
        worker.RunWorkerCompleted += Worker_RunWorkerCompleted;

        buttonCancel.Enabled = false;
    }

    private void buttonStart_Click(object sender, EventArgs e)
    {
        if (worker.IsBusy)
        {
            return;
        }

        progressBar1.Value = 0;
        labelStatus.Text = "処理中...";
        buttonStart.Enabled = false;
        buttonCancel.Enabled = true;

        worker.RunWorkerAsync();
    }

    private void buttonCancel_Click(object sender, EventArgs e)
    {
        if (worker.IsBusy)
        {
            worker.CancelAsync();
            labelStatus.Text = "キャンセル要求中...";
            buttonCancel.Enabled = false;
        }
    }

    private void Worker_DoWork(object sender, DoWorkEventArgs e)
    {
        BackgroundWorker bw = (BackgroundWorker)sender;

        int total = 50;

        for (int i = 0; i < total; i++)
        {
            if (bw.CancellationPending)
            {
                e.Cancel = true;
                return;
            }

            Thread.Sleep(100);

            int percent = (i + 1) * 100 / total;
            bw.ReportProgress(percent, $"{i + 1} / {total} 件を処理中");
        }
    }

    private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        progressBar1.Value = e.ProgressPercentage;
        labelStatus.Text = e.UserState?.ToString();
    }

    private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        buttonStart.Enabled = true;
        buttonCancel.Enabled = false;

        if (e.Cancelled)
        {
            labelStatus.Text = "キャンセルされました";
        }
        else if (e.Error != null)
        {
            labelStatus.Text = "エラーが発生しました";
            MessageBox.Show(e.Error.Message);
        }
        else
        {
            progressBar1.Value = 100;
            labelStatus.Text = "完了しました";
        }
    }
}

6-6. キャンセルできない実装になってしまう原因

キャンセルボタンを押しても止まらない場合、よくある原因は次のとおりです。

BackgroundWorkerのキャンセルは強制終了ではありません。処理側がキャンセル要求を見に行き、自分で終了する必要があります。

7. BackgroundWorkerで引数や戻り値を扱う方法

7-1. RunWorkerAsyncの引数をDoWorkで受け取る

BackgroundWorkerでは、RunWorkerAsyncに引数を渡せます。

C#
worker.RunWorkerAsync(10);

この値は、DoWorkイベントで受け取ります。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    int count = (int)e.Argument;
}

7-2. DoWorkEventArgs.Argumentの使い方

e.Argumentはobject型なので、受け取るときはキャストが必要です。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    string filePath = (string)e.Argument;

    // filePathを使って処理する
}

複数の値を渡す場合は、クラスやタプルを使うと便利です。

7-3. e.Resultで処理結果を返す

DoWork内で処理結果を返したい場合は、e.Resultに値を設定します。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    int count = (int)e.Argument;

    int result = count * 2;

    e.Result = result;
}

7-4. RunWorkerCompletedEventArgs.Resultで結果を取得する

e.Resultに設定した値は、RunWorkerCompletedで取得できます。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Error != null)
    {
        MessageBox.Show(e.Error.Message);
        return;
    }

    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
        return;
    }

    int result = (int)e.Result;
    labelStatus.Text = $"結果：{result}";
}

ここでも、Resultへアクセスする前にErrorとCancelledを確認することが重要です。

7-5. 複数の値を渡す場合のクラス・タプル・DTOの使い分け

複数の値を渡す方法はいくつかあります。

初心者には、まずクラスを作る方法がおすすめです。値の意味がわかりやすく、後から項目を追加しやすいためです。

C#
public class SearchRequest
{
    public string Keyword { get; set; }
    public int MaxCount { get; set; }
}

戻り値もクラスにできます。

C#
public class SearchResult
{
    public int Count { get; set; }
    public string Message { get; set; }
}

7-6. 引数と戻り値を使った実用サンプルコード

C#
public class ProcessRequest
{
    public int Count { get; set; }
    public string Name { get; set; }
}

public class ProcessResult
{
    public int Total { get; set; }
    public string Message { get; set; }
}

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    if (worker.IsBusy)
    {
        return;
    }

    var request = new ProcessRequest
    {
        Count = 10,
        Name = "サンプル処理"
    };

    worker.RunWorkerAsync(request);
}

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    var request = (ProcessRequest)e.Argument;

    int total = 0;

    for (int i = 1; i <= request.Count; i++)
    {
        Thread.Sleep(100);
        total += i;
    }

    e.Result = new ProcessResult
    {
        Total = total,
        Message = $"{request.Name}が完了しました"
    };
}

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Error != null)
    {
        MessageBox.Show(e.Error.Message);
        return;
    }

    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
        return;
    }

    var result = (ProcessResult)e.Result;

    labelStatus.Text = $"{result.Message} 合計：{result.Total}";
}

8. 例外処理とエラー表示の実装

8-1. DoWork内で例外が発生した場合の動き

DoWork内で例外が発生した場合、その例外はRunWorkerCompletedのe.Errorで確認できます。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    throw new InvalidOperationException("サンプルエラーです");
}

この例外は、RunWorkerCompletedで次のように受け取ります。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Error != null)
    {
        MessageBox.Show(e.Error.Message);
    }
}

8-2. RunWorkerCompletedのErrorプロパティを確認する

エラー処理では、まずe.Errorを確認します。

C#
if (e.Error != null)
{
    MessageBox.Show($"エラーが発生しました：{e.Error.Message}");
    return;
}

その後にe.Cancelled、最後に正常完了を処理すると安全です。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Error != null)
    {
        MessageBox.Show($"エラー：{e.Error.Message}");
    }
    else if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
    }
    else
    {
        labelStatus.Text = "正常に完了しました";
    }
}

8-3. MessageBoxでエラー内容を表示する

初心者向けの実装では、まずMessageBox.Showでエラー内容を表示するとわかりやすいです。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Error != null)
    {
        labelStatus.Text = "エラーが発生しました";

        MessageBox.Show(
            e.Error.Message,
            "エラー",
            MessageBoxButtons.OK,
            MessageBoxIcon.Error);

        return;
    }

    labelStatus.Text = "完了しました";
}

実務では、ログファイルにエラー内容を出力する処理も追加するとよいでしょう。

8-4. finally相当の後片付けをどこに書くべきか

BackgroundWorkerでは、後片付けの内容によって書く場所を分けます。

UIに関係する後片付けはRunWorkerCompletedに書きます。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    buttonStart.Enabled = true;
    buttonCancel.Enabled = false;
    progressBar1.Style = ProgressBarStyle.Blocks;
}

ファイルやリソースの解放はDoWork内で行います。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    using (var stream = File.OpenRead("sample.txt"))
    {
        // ファイル処理
    }
}

8-5. エラー時にUIを安全に復旧するコード例

エラーが発生してもボタンが無効のままにならないように、UI復旧処理は最後にまとめます。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    buttonStart.Enabled = true;
    buttonCancel.Enabled = false;
    progressBar1.Style = ProgressBarStyle.Blocks;

    if (e.Error != null)
    {
        labelStatus.Text = "エラーが発生しました";

        MessageBox.Show(
            e.Error.Message,
            "エラー",
            MessageBoxButtons.OK,
            MessageBoxIcon.Error);

        return;
    }

    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
        return;
    }

    progressBar1.Value = 100;
    labelStatus.Text = "完了しました";
}

このように、ボタンやProgressBarを元に戻す処理を最初に書くと、エラー時でも画面が復旧しやすくなります。

9. BackgroundWorkerでよくあるエラーと解決策

9-1. 「別スレッドから呼び出されたため、コントロールにアクセスできません」の原因

このエラーは、DoWork内でUIコントロールを直接操作したときによく発生します。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    // NG
    labelStatus.Text = "処理中...";
}

解決策は、ReportProgressを使ってProgressChangedでUIを更新することです。

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    BackgroundWorker bw = (BackgroundWorker)sender;
    bw.ReportProgress(0, "処理中...");
}

private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    labelStatus.Text = e.UserState?.ToString();
}

9-2. ProgressChangedが呼ばれない原因

ProgressChangedが呼ばれない場合は、次を確認します。

よくあるミスは、WorkerReportsProgressの設定忘れです。

C#
worker.WorkerReportsProgress = true;

9-3. キャンセルボタンを押しても止まらない原因

キャンセルできない場合は、次を確認します。

C#
worker.WorkerSupportsCancellation = true;

C#
worker.CancelAsync();

C#
if (worker.CancellationPending)
{
    e.Cancel = true;
    return;
}

CancelAsyncだけでは処理は止まりません。DoWork内でCancellationPendingを確認し、e.Cancel = trueを設定して処理を抜ける必要があります。

9-4. RunWorkerAsyncを連続実行してエラーになる原因

BackgroundWorkerは、実行中に再度RunWorkerAsyncを呼ぶとエラーになります。対策としてIsBusyを確認します。

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    if (worker.IsBusy)
    {
        MessageBox.Show("すでに処理中です。");
        return;
    }

    worker.RunWorkerAsync();
}

また、処理中は開始ボタンを無効化しておくと、二重実行を防ぎやすくなります。

C#
buttonStart.Enabled = false;

9-5. 処理完了後にResultを取得すると例外になる原因

RunWorkerCompletedでe.Resultにアクセスする前に、e.Errorとe.Cancelledを確認していない場合、例外が発生することがあります。

悪い例です。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    // NG
    var result = e.Result;
}

良い例です。

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (e.Error != null)
    {
        MessageBox.Show(e.Error.Message);
        return;
    }

    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
        return;
    }

    var result = e.Result;
}

RunWorkerCompletedEventArgs.Resultは、エラーやキャンセルの状態によって例外を発生させる可能性があるため、先に状態確認を行うのが基本です。

9-6. デバッグ時に確認すべきチェックリスト

BackgroundWorkerがうまく動かないときは、次のチェックリストを確認してください。

10. 実践サンプル：時間のかかる処理を進捗表示・キャンセル対応で実装する

10-1. 作成するサンプルアプリの概要

ここでは、次の機能を持つWindows Formsアプリを作成します。

処理内容は、100件のデータを順番に処理する想定にします。

10-2. 画面に配置するコントロール一覧

フォームには次のコントロールを配置します。

初期状態では、キャンセルボタンを無効にしておきます。

C#
buttonCancel.Enabled = false;

10-3. BackgroundWorkerの初期設定コード

C#
private BackgroundWorker worker = new BackgroundWorker();

public Form1()
{
    InitializeComponent();

    worker.WorkerReportsProgress = true;
    worker.WorkerSupportsCancellation = true;

    worker.DoWork += Worker_DoWork;
    worker.ProgressChanged += Worker_ProgressChanged;
    worker.RunWorkerCompleted += Worker_RunWorkerCompleted;

    buttonCancel.Enabled = false;
    progressBar1.Minimum = 0;
    progressBar1.Maximum = 100;
    progressBar1.Value = 0;
    labelStatus.Text = "待機中";
}

10-4. 開始ボタンの処理

C#
private void buttonStart_Click(object sender, EventArgs e)
{
    if (worker.IsBusy)
    {
        MessageBox.Show("すでに処理中です。");
        return;
    }

    progressBar1.Value = 0;
    labelStatus.Text = "処理を開始しました";

    buttonStart.Enabled = false;
    buttonCancel.Enabled = true;

    worker.RunWorkerAsync(100);
}

ここでは、RunWorkerAsync(100)で処理件数を渡しています。

10-5. DoWork内の重い処理

C#
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    BackgroundWorker bw = (BackgroundWorker)sender;

    int totalCount = (int)e.Argument;
    int processedCount = 0;

    for (int i = 0; i < totalCount; i++)
    {
        if (bw.CancellationPending)
        {
            e.Cancel = true;
            return;
        }

        // 重い処理の代わり
        Thread.Sleep(50);

        processedCount++;

        int percent = processedCount * 100 / totalCount;
        string message = $"{processedCount} / {totalCount} 件を処理しました";

        bw.ReportProgress(percent, message);
    }

    e.Result = processedCount;
}

10-6. 進捗表示の更新処理

C#
private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progressBar1.Value = e.ProgressPercentage;
    labelStatus.Text = e.UserState?.ToString();
}

ProgressChangedではUIコントロールを安全に更新できます。

10-7. キャンセルボタンの処理

C#
private void buttonCancel_Click(object sender, EventArgs e)
{
    if (!worker.IsBusy)
    {
        return;
    }

    worker.CancelAsync();

    buttonCancel.Enabled = false;
    labelStatus.Text = "キャンセル要求中...";
}

CancelAsyncはキャンセル要求を出すだけなので、実際の停止はDoWork内のCancellationPendingチェックで行います。

10-8. 完了・キャンセル・エラー時の表示切り替え

C#
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    buttonStart.Enabled = true;
    buttonCancel.Enabled = false;

    if (e.Error != null)
    {
        labelStatus.Text = "エラーが発生しました";

        MessageBox.Show(
            e.Error.Message,
            "エラー",
            MessageBoxButtons.OK,
            MessageBoxIcon.Error);

        return;
    }

    if (e.Cancelled)
    {
        labelStatus.Text = "キャンセルされました";
        return;
    }

    int processedCount = (int)e.Result;

    progressBar1.Value = 100;
    labelStatus.Text = $"{processedCount} 件の処理が完了しました";
}