C#のProcessクラス完全ガイド｜外部プロセスの起動・終了・標準出力取得まで実例で解説

はじめに

C#で外部のexe、コマンド、バッチファイル、PowerShell、Python、Node.jsなどを実行したいときに使う代表的なクラスがProcessクラスです。たとえば、C#アプリからpingコマンドを実行して結果を取得したり、別アプリを起動したり、実行中のプロセスを終了したり、標準出力・標準エラーをログに保存したりできます。

一方で、Processクラスは便利な反面、UseShellExecute、RedirectStandardOutput、WaitForExit、Killなどの設定を誤ると、標準出力が取得できない、プロセスが固まる、コマンドインジェクションの危険がある、といった問題が起きやすい機能でもあります。

この記事では、C#のProcessクラスを使った外部プロセスの起動、終了待ち、強制終了、標準出力取得、標準エラー取得、標準入力、非同期実行、実践サンプル、よくあるエラー、安全な使い方まで実例付きで解説します。

1. C#のProcessクラスとは

Processクラスは、C#からOS上のプロセスを操作するためのクラスです。System.Diagnostics名前空間に用意されており、外部プログラムの起動、実行中プロセスの情報取得、終了待ち、終了、標準入出力のリダイレクトなどに利用できます。Microsoftのドキュメントでも、Processはプロセスリソースの開始や関連付けに使われるクラスとして説明されています。Microsoft Learn

1-1. Processクラスでできること

C#のProcessクラスでは、主に次のような処理ができます。

• 外部exeを起動する

• コマンドプロンプトやPowerShellのコマンドを実行する

• URL、ファイル、フォルダを開く

• 外部プロセスの終了を待つ

• 終了コードを取得する

• 標準出力を取得する

• 標準エラー出力を取得する

• 標準入力に値を渡す

• 実行中のプロセスを終了・強制終了する

• 非同期でプロセスの終了や出力を監視する

たとえば、C#からメモ帳を起動するだけなら、次のように書けます。

C#
using System.Diagnostics;

Process.Start("notepad.exe");

このように、単純な外部アプリの起動であれば非常に少ないコードで実装できます。

1-2. 外部プロセスを扱う代表的な用途

Processクラスは、業務アプリやツール開発でよく使われます。代表的な用途は次の通りです。

特に、既存のコマンドラインツールとC#アプリを連携させる場合、Processクラスは非常に強力です。

1-3. Processクラスを使う前に知っておきたい基本用語

Processクラスを理解するには、いくつかの用語を押さえておくとスムーズです。

たとえば、コマンドプロンプトで次のように実行する場合、

cmd
ping example.com

pingが実行ファイル名、example.comが引数です。

1-4. System.Diagnostics名前空間の役割

ProcessクラスはSystem.Diagnostics名前空間に含まれています。そのため、C#で使う場合は基本的に次のusingを追加します。

C#
using System.Diagnostics;

System.Diagnosticsには、プロセス操作だけでなく、ログ出力、トレース、デバッグ支援など、診断に関するクラスが含まれています。Processクラスもその一部で、外部プロセスの状態確認や実行結果の取得に使われます。

2. C#で外部プロセスを起動する基本

2-1. Process.Startでexeやコマンドを実行する方法

外部プロセスを起動する基本はProcess.Startです。もっともシンプルな例は次の通りです。

C#
using System.Diagnostics;

Process.Start("notepad.exe");

コマンドを実行する場合は、実行ファイル名と引数を分けて指定します。

C#
using System.Diagnostics;

Process.Start("ping", "example.com");

ただし、標準出力を取得したい場合や、作業ディレクトリ、文字コード、ウィンドウ表示などを細かく制御したい場合は、ProcessStartInfoを使うのが基本です。

2-2. ProcessStartInfoを使った起動設定の基本

ProcessStartInfoは、プロセス起動時の設定をまとめるクラスです。Microsoftのドキュメントでは、ProcessStartInfoはプロセス起動時に使われるファイル名やコマンドライン引数などの情報を指定するクラスとして説明されています。Microsoft Learn

基本形は次の通りです。

C#
using System.Diagnostics;

var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false
};

using var process = Process.Start(startInfo);
process?.WaitForExit();

FileNameに実行するプログラム、Argumentsに引数、UseShellExecuteにシェルを使うかどうかを指定します。

2-3. FileNameとArgumentsの指定方法

FileNameには実行するファイル名を指定します。Argumentsにはコマンドライン引数を文字列で指定します。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "-n 4 example.com",
    UseShellExecute = false
};

Windowsのcmd.exeでコマンドを実行する場合は、次のように/cを使います。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c dir",
    UseShellExecute = false
};

/cは「コマンドを実行したら終了する」という意味です。対話的にコマンドプロンプトを開いたままにしたい場合は/kを使います。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/k dir",
    UseShellExecute = true
};

ただし、ユーザー入力をそのままArgumentsに連結するのは危険です。安全性を高めるには、可能であればArgumentListを使います。ArgumentListに追加した文字列は、事前にエスケープする必要がない引数コレクションとして扱われます。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    UseShellExecute = false
};

startInfo.ArgumentList.Add("example.com");

2-4. 作業ディレクトリを指定する方法

外部プロセスのカレントディレクトリを指定したい場合は、WorkingDirectoryを使います。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "mytool.exe",
    Arguments = "input.txt",
    WorkingDirectory = @"C:\Tools\MyTool",
    UseShellExecute = false
};

using var process = Process.Start(startInfo);
process?.WaitForExit();

WorkingDirectoryは、相対パスでファイルを読む外部ツールを実行するときに重要です。

C#
// C:\Tools\MyTool\input.txt を参照する想定
Arguments = "input.txt"

なお、WorkingDirectoryの解釈はUseShellExecuteの値によって変わります。UseShellExecute=falseでは起動後プロセスの作業ディレクトリとして使われ、UseShellExecute=trueでは実行ファイルを探す場所として扱われます。Microsoft Learn

2-5. URL・ファイル・フォルダを開く方法

URL、ファイル、フォルダを既定のアプリで開くには、UseShellExecute=trueを指定します。

C#
using System.Diagnostics;

Process.Start(new ProcessStartInfo
{
    FileName = "https://example.com",
    UseShellExecute = true
});

フォルダを開く例です。

C#
Process.Start(new ProcessStartInfo
{
    FileName = @"C:\Temp",
    UseShellExecute = true
});

PDFやテキストファイルを既定のアプリで開く例です。

C#
Process.Start(new ProcessStartInfo
{
    FileName = @"C:\Temp\sample.pdf",
    UseShellExecute = true
});

UseShellExecute=falseの場合、Processで起動できるのは基本的に実行ファイルです。ドキュメントやURLを既定のアプリで開く場合はUseShellExecute=trueを使います。Microsoft Learn

3. ProcessStartInfoの主要プロパティ

3-1. UseShellExecuteの意味とtrue・falseの違い

UseShellExecuteは、OSのシェルを使ってプロセスを起動するかどうかを指定する重要なプロパティです。Microsoftのドキュメントでは、UseShellExecute=trueはシェルを使ってプロセスを開始し、falseは実行ファイルから直接プロセスを作成する設定と説明されています。既定値は.NETではfalse、.NET Frameworkではtrueです。Microsoft Learn

標準出力や標準エラーを取得する場合は、原則としてUseShellExecute=falseにします。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false,
    RedirectStandardOutput = true
};

3-2. CreateNoWindowで黒い画面を非表示にする方法

コンソールアプリを実行するとき、黒い画面を表示したくない場合はCreateNoWindow=trueを指定します。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c dir",
    UseShellExecute = false,
    CreateNoWindow = true
};

標準出力を裏側で取得する処理では、次のように組み合わせることが多いです。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    CreateNoWindow = true
};

3-3. WindowStyleでウィンドウ表示を制御する方法

WindowStyleを使うと、起動するウィンドウの表示状態を制御できます。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "notepad.exe",
    WindowStyle = ProcessWindowStyle.Minimized
};

Process.Start(startInfo);

指定できる代表的な値は次の通りです。

ただし、すべてのアプリが指定通りに表示されるとは限りません。アプリ側の実装やOSの制約によって動作が異なる場合があります。

3-4. Verbを使って管理者権限で実行する方法

Windowsで管理者権限として実行したい場合は、Verb = "runas"を指定します。Verbは、FileNameで指定したアプリケーションやドキュメントを開くときに使う動詞を指定するプロパティです。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c net session",
    UseShellExecute = true,
    Verb = "runas"
};

Process.Start(startInfo);

管理者権限で起動する場合、通常はUACの確認ダイアログが表示されます。また、Verb="runas"を使うには基本的にUseShellExecute=trueが必要です。

3-5. EnvironmentVariablesで環境変数を渡す方法

外部プロセスに環境変数を渡したい場合は、EnvironmentVariablesまたはEnvironmentを使います。ProcessStartInfoには、起動するプロセスや子プロセスに適用される環境変数を設定するプロパティが用意されています。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c echo %MY_VALUE%",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    CreateNoWindow = true
};

startInfo.EnvironmentVariables["MY_VALUE"] = "Hello Process";

using var process = Process.Start(startInfo);
string output = process!.StandardOutput.ReadToEnd();
process.WaitForExit();

Console.WriteLine(output);

環境変数は、外部ツールに設定値や認証情報の一部を渡すときに使えます。ただし、機密情報を環境変数で渡す場合は、ログや子プロセスへの伝播に注意が必要です。

4. 外部プロセスの終了を待つ方法

4-1. WaitForExitの基本的な使い方

外部プロセスが終了するまで待つにはWaitForExitを使います。

C#
using var process = Process.Start("notepad.exe");

process?.WaitForExit();

Console.WriteLine("メモ帳が終了しました。");

コマンド実行結果を取得する場合も、通常は読み取り後または非同期読み取りの完了確認としてWaitForExitを使います。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false,
    RedirectStandardOutput = true
};

using var process = Process.Start(startInfo);
string output = process!.StandardOutput.ReadToEnd();
process.WaitForExit();

Console.WriteLine(output);

4-2. タイムアウト付きで終了を待つ方法

外部プロセスが固まる可能性がある場合は、タイムアウトを設定します。

C#
using var process = Process.Start("notepad.exe");

bool exited = process!.WaitForExit(5000);

if (exited)
{
    Console.WriteLine("5秒以内に終了しました。");
}
else
{
    Console.WriteLine("5秒以内に終了しませんでした。");
}

タイムアウト後に強制終了する例です。

C#
using var process = Process.Start("notepad.exe");

if (!process!.WaitForExit(5000))
{
    process.Kill();
    process.WaitForExit();
}

外部コマンドやユーザー操作待ちのアプリをC#から実行する場合、無期限に待つWaitForExit()だけに頼るとアプリ全体が止まる原因になります。

4-3. ExitCodeで実行結果を判定する方法

プロセスが終了した後は、ExitCodeで終了コードを取得できます。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c exit 1",
    UseShellExecute = false,
    CreateNoWindow = true
};

using var process = Process.Start(startInfo);
process!.WaitForExit();

Console.WriteLine($"ExitCode: {process.ExitCode}");

一般的には、終了コード0が成功、0以外がエラーを表すことが多いです。ただし、終了コードの意味は実行する外部プログラムによって異なります。

C#
if (process.ExitCode == 0)
{
    Console.WriteLine("成功");
}
else
{
    Console.WriteLine("失敗");
}

4-4. HasExitedで終了状態を確認する方法

HasExitedを使うと、プロセスがすでに終了しているかを確認できます。

C#
using var process = Process.Start("notepad.exe");

Thread.Sleep(3000);

if (process!.HasExited)
{
    Console.WriteLine("終了済みです。");
}
else
{
    Console.WriteLine("まだ実行中です。");
}

KillやCloseMainWindowを呼び出した後に終了確認する場合にも使います。

C#
if (!process.HasExited)
{
    process.Kill();
}

4-5. Exitedイベントで非同期に終了を検知する方法

プロセス終了をイベントで検知したい場合は、Exitedイベントを使います。Exitedイベントを使うにはEnableRaisingEvents=trueを設定します。

C#
var process = new Process
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "notepad.exe"
    },
    EnableRaisingEvents = true
};

process.Exited += (sender, e) =>
{
    Console.WriteLine("プロセスが終了しました。");
    process.Dispose();
};

process.Start();

画面をブロックせずに終了を検知したいGUIアプリや常駐ツールでは、Exitedイベントが便利です。

5. 外部プロセスを終了・強制終了する方法

5-1. CloseMainWindowで正常終了を依頼する方法

GUIアプリを通常終了させたい場合は、CloseMainWindowを使います。これは、対象プロセスのメインウィンドウへ閉じるメッセージを送るメソッドです。戻り値は、閉じるメッセージを送信できた場合にtrue、メインウィンドウがない場合や無効な場合にfalseになります。Microsoft Learn

C#
using var process = Process.Start("notepad.exe");

Thread.Sleep(3000);

if (!process!.HasExited)
{
    bool requested = process.CloseMainWindow();

    if (requested)
    {
        process.WaitForExit(5000);
    }
}

CloseMainWindowは「終了してください」と依頼する方法です。未保存ファイルがある場合、アプリが確認ダイアログを表示し、終了しないこともあります。

5-2. Killでプロセスを強制終了する方法

プロセスを強制終了するにはKillを使います。Microsoftのドキュメントでも、Killは関連付けられたプロセスを強制終了するメソッドとして説明されています。Microsoft Learn

C#
using var process = Process.Start("notepad.exe");

Thread.Sleep(3000);

if (!process!.HasExited)
{
    process.Kill();
    process.WaitForExit();
}

Killは強力ですが、編集中データや処理中リソースが失われる可能性があります。そのため、まずCloseMainWindowで正常終了を依頼し、終了しない場合だけKillする流れが安全です。

5-3. KillとCloseMainWindowの使い分け

KillとCloseMainWindowの違いは次の通りです。

ドキュメントでも、CloseMainWindowは終了を要求するだけで強制終了ではなく、アプリが終了を拒否する可能性があるため、強制終了が必要な場合はKillを使うと説明されています。Microsoft Learn

推奨パターンは次のようになります。

C#
if (!process.HasExited)
{
    if (process.CloseMainWindow())
    {
        if (!process.WaitForExit(5000))
        {
            process.Kill();
        }
    }
    else
    {
        process.Kill();
    }
}

5-4. 子プロセスごと終了させる方法

.NETでは、Kill(true)を使うことで、関連プロセスと子孫プロセスをまとめて終了できます。Kill(bool entireProcessTree)の引数にtrueを指定すると、関連プロセスとその子孫プロセスを終了対象にできます。Microsoft Learn

C#
if (!process.HasExited)
{
    process.Kill(entireProcessTree: true);
    process.WaitForExit();
}

ただし、Kill(entireProcessTree: true)を使っても、権限やOSの状態によってすべての子孫プロセスを終了できるとは限りません。また、WaitForExitやHasExitedは指定した親プロセスの終了状態を反映するもので、すべての子孫プロセス終了を完全に保証するものではありません。Microsoft Learn

5-5. 終了処理で注意すべきリソース解放

ProcessはOSリソースを扱うため、使い終わったら破棄することが重要です。基本的にはusingを使います。

C#
using var process = Process.Start("notepad.exe");
process?.WaitForExit();

Processオブジェクトを長時間保持する場合は、不要になったタイミングでDisposeを呼び出します。

C#
process.Dispose();

また、強制終了後もすぐに終了状態が反映されるとは限らないため、Killの後にWaitForExitを呼ぶのが安全です。Killは非同期的に実行されるため、呼び出し後にWaitForExitまたはHasExitedで終了を確認する必要があります。Microsoft Learn

6. 標準出力を取得する方法

6-1. RedirectStandardOutputの基本

C#で外部プロセスの標準出力を取得するには、RedirectStandardOutput=trueを指定します。RedirectStandardOutputは、アプリケーションのテキスト出力をStandardOutputストリームに書き込むかどうかを指定するプロパティです。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    CreateNoWindow = true
};

この設定により、通常コンソール画面に表示される結果をC#側で文字列として取得できます。

6-2. StandardOutput.ReadToEndで出力を取得する方法

標準出力をまとめて取得するには、StandardOutput.ReadToEnd()を使います。

C#
using System.Diagnostics;
using System.Text;

var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    CreateNoWindow = true,
    StandardOutputEncoding = Encoding.UTF8
};

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
process.WaitForExit();

Console.WriteLine(output);

ReadToEndは、プロセスが標準出力を閉じるまで読み取りを続けます。そのため、プロセスが終了しないコマンドでは処理が戻ってこない可能性があります。

6-3. 標準出力取得時に必要なUseShellExecute=false

標準出力を取得する場合、UseShellExecute=falseが必要です。Microsoftのドキュメントでも、RedirectStandardOutput=trueにするにはUseShellExecute=falseを設定する必要があり、そうしないとStandardOutputの読み取りで例外が発生すると説明されています。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c echo Hello",
    UseShellExecute = false,
    RedirectStandardOutput = true
};

標準出力が取得できない場合、まずUseShellExecute=falseになっているかを確認しましょう。

6-4. 文字化けを防ぐエンコーディング指定

外部コマンドの出力が文字化けする場合は、StandardOutputEncodingを指定します。

C#
using System.Diagnostics;
using System.Text;

var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c echo こんにちは",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    CreateNoWindow = true,
    StandardOutputEncoding = Encoding.UTF8
};

Windowsの古いコマンドでは、Shift_JIS相当のコードページを使うこともあります。その場合は次のように指定します。

C#
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c echo こんにちは",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    StandardOutputEncoding = Encoding.GetEncoding(932)
};

外部プログラムがUTF-8で出力しているならEncoding.UTF8、日本語Windowsのレガシーコマンド出力ならEncoding.GetEncoding(932)を検討します。

6-5. 標準出力をリアルタイムに取得する方法

リアルタイムに標準出力を取得するには、OutputDataReceivedイベントとBeginOutputReadLineを使います。非同期読み取りを行うには、UseShellExecute=falseとRedirectStandardOutput=trueを設定したうえでBeginOutputReadLineを呼び出します。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    CreateNoWindow = true
};

using var process = new Process
{
    StartInfo = startInfo,
    EnableRaisingEvents = true
};

process.OutputDataReceived += (sender, e) =>
{
    if (e.Data != null)
    {
        Console.WriteLine($"OUT: {e.Data}");
    }
};

process.Start();
process.BeginOutputReadLine();
process.WaitForExit();

長時間実行されるコマンドや進捗を逐次表示したい処理では、ReadToEndよりリアルタイム取得の方が向いています。

7. 標準エラー出力を取得する方法

7-1. RedirectStandardErrorの基本

標準エラー出力を取得するには、RedirectStandardError=trueを指定します。RedirectStandardErrorは、アプリケーションのエラー出力をStandardErrorストリームに書き込むかどうかを指定するプロパティです。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c dir C:\\not_exists",
    UseShellExecute = false,
    RedirectStandardError = true,
    CreateNoWindow = true
};

標準出力と同様に、標準エラーをリダイレクトする場合もUseShellExecute=falseが必要です。Microsoft Learn

7-2. StandardError.ReadToEndでエラー内容を取得する方法

標準エラーをまとめて取得するには、StandardError.ReadToEnd()を使います。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c dir C:\\not_exists",
    UseShellExecute = false,
    RedirectStandardError = true,
    CreateNoWindow = true
};

using var process = Process.Start(startInfo);

string error = process!.StandardError.ReadToEnd();
process.WaitForExit();

Console.WriteLine(error);

外部コマンドが失敗した理由をログに残したい場合、標準エラーの取得は非常に重要です。

7-3. 標準出力と標準エラーを同時に扱う方法

実務では、標準出力と標準エラーの両方を取得することが多いです。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c dir C:\\not_exists",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true
};

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

Console.WriteLine("Output:");
Console.WriteLine(output);

Console.WriteLine("Error:");
Console.WriteLine(error);

ただし、標準出力と標準エラーを同期的に両方読む場合、出力量が多いとデッドロックが発生する可能性があります。安全性を高めるには、少なくとも片方を非同期で読み取る、または両方を非同期で読み取る方法を使います。

7-4. エラー内容をログに保存する実装例

標準エラーをログファイルに保存する例です。

C#
using System.Diagnostics;
using System.Text;

var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c dir C:\\not_exists",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true,
    StandardOutputEncoding = Encoding.UTF8,
    StandardErrorEncoding = Encoding.UTF8
};

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

File.WriteAllText("output.log", output, Encoding.UTF8);
File.WriteAllText("error.log", error, Encoding.UTF8);

Console.WriteLine($"ExitCode: {process.ExitCode}");

エラーが発生したときだけログに保存するなら、ExitCodeを見て分岐します。

C#
if (process.ExitCode != 0)
{
    File.WriteAllText("error.log", error, Encoding.UTF8);
}

7-5. デッドロックを避ける読み取り順序

標準出力や標準エラーのリダイレクトでは、読み取り順序に注意が必要です。Microsoftのドキュメントでも、親プロセスが読み取り待ち、子プロセスが満杯のストリームへの書き込み待ちになることでデッドロックが起きる可能性が説明されています。Microsoft Learn

危険な例です。

C#
// 出力量が多い場合、デッドロックの可能性がある
string output = process.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();
process.WaitForExit();

安全なパターンの一つは、標準エラーを非同期で読み取り、標準出力を同期で読む方法です。

C#
var errorBuilder = new StringBuilder();

using var process = new Process
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "cmd.exe",
        Arguments = "/c your-command",
        UseShellExecute = false,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        CreateNoWindow = true
    }
};

process.ErrorDataReceived += (sender, e) =>
{
    if (e.Data != null)
    {
        errorBuilder.AppendLine(e.Data);
    }
};

process.Start();
process.BeginErrorReadLine();

string output = process.StandardOutput.ReadToEnd();
process.WaitForExit();

string error = errorBuilder.ToString();

より安全にするなら、標準出力と標準エラーの両方を非同期で読み取る設計にします。

8. 標準入力に値を渡す方法

8-1. RedirectStandardInputの基本

外部プロセスにC#から入力を渡したい場合は、RedirectStandardInput=trueを指定します。RedirectStandardInputは、アプリケーションの入力をStandardInputストリームから読み取るかどうかを指定するプロパティです。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "sort.exe",
    UseShellExecute = false,
    RedirectStandardInput = true
};

sortのように標準入力から文字列を受け取るコマンドに対して有効です。

8-2. StandardInput.WriteLineで入力を送る方法

StandardInput.WriteLineを使うと、外部プロセスに1行ずつ入力を送れます。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "sort.exe",
    UseShellExecute = false,
    RedirectStandardInput = true,
    RedirectStandardOutput = true,
    CreateNoWindow = true
};

using var process = Process.Start(startInfo);

process!.StandardInput.WriteLine("orange");
process.StandardInput.WriteLine("apple");
process.StandardInput.WriteLine("banana");
process.StandardInput.Close();

string output = process.StandardOutput.ReadToEnd();
process.WaitForExit();

Console.WriteLine(output);

この例では、sort.exeに複数行の入力を渡し、並び替え結果を標準出力から取得しています。

8-3. 入力後にCloseする理由

標準入力に値を渡した後は、StandardInput.Close()を呼び出します。

C#
process.StandardInput.Close();

これを呼ばないと、外部プロセス側は「まだ入力が続く」と判断して待ち続けることがあります。Microsoftのサンプルでも、標準入力の書き込み後にストリームを閉じることで、コマンドが入力終了を認識して処理を進める流れが示されています。Microsoft Learn

8-4. 対話型コマンドを操作する実装例

対話型コマンドを操作する場合も、標準入力・標準出力・標準エラーをリダイレクトします。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c set /p name=Name: & echo Hello %name%",
    UseShellExecute = false,
    RedirectStandardInput = true,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true
};

using var process = Process.Start(startInfo);

process!.StandardInput.WriteLine("Taro");
process.StandardInput.Close();

string output = process.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

Console.WriteLine(output);
Console.WriteLine(error);

ただし、複雑な対話型プログラムは、単純な標準入力だけでは制御が難しい場合があります。プロンプトの表示タイミング、バッファリング、エコーバック、文字コードなどの影響を受けるため、可能であれば非対話モードや引数指定で実行できるツールを選ぶ方が安定します。

9. 非同期でProcessを扱う方法

9-1. WaitForExitAsyncの使い方

.NETでは、WaitForExitAsyncを使ってプロセス終了を非同期に待てます。WaitForExitAsyncは、関連付けられたプロセスが終了するか、キャンセルトークンがキャンセルされるまで待機するタスクを返します。Microsoft Learn

C#
var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false,
    CreateNoWindow = true
};

using var process = Process.Start(startInfo);

await process!.WaitForExitAsync();

Console.WriteLine("終了しました。");

GUIアプリ、ASP.NET、バックグラウンドサービスなど、スレッドをブロックしたくない処理ではWaitForExitAsyncが便利です。

9-2. OutputDataReceivedで標準出力を非同期取得する方法

標準出力を非同期に取得するには、OutputDataReceivedイベントを使います。

C#
var outputLines = new List<string>();

using var process = new Process
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "ping",
        Arguments = "example.com",
        UseShellExecute = false,
        RedirectStandardOutput = true,
        CreateNoWindow = true
    }
};

process.OutputDataReceived += (sender, e) =>
{
    if (e.Data != null)
    {
        outputLines.Add(e.Data);
        Console.WriteLine(e.Data);
    }
};

process.Start();
process.BeginOutputReadLine();

await process.WaitForExitAsync();

BeginOutputReadLineを呼ばないと、イベントによる読み取りは開始されません。

9-3. ErrorDataReceivedで標準エラーを非同期取得する方法

標準エラーを非同期に取得するには、ErrorDataReceivedイベントを使います。

C#
var errorLines = new List<string>();

using var process = new Process
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "cmd.exe",
        Arguments = "/c dir C:\\not_exists",
        UseShellExecute = false,
        RedirectStandardError = true,
        CreateNoWindow = true
    }
};

process.ErrorDataReceived += (sender, e) =>
{
    if (e.Data != null)
    {
        errorLines.Add(e.Data);
        Console.Error.WriteLine(e.Data);
    }
};

process.Start();
process.BeginErrorReadLine();

await process.WaitForExitAsync();

標準出力と標準エラーの両方を扱う場合は、OutputDataReceivedとErrorDataReceivedを両方使うのが安全です。

9-4. BeginOutputReadLineとBeginErrorReadLineの使い方

BeginOutputReadLineは標準出力の非同期読み取りを開始し、BeginErrorReadLineは標準エラーの非同期読み取りを開始します。

C#
process.Start();

process.BeginOutputReadLine();
process.BeginErrorReadLine();

await process.WaitForExitAsync();

呼び出し順序は、基本的にStart()の後です。

C#
process.Start();              // プロセス開始
process.BeginOutputReadLine(); // 標準出力の読み取り開始
process.BeginErrorReadLine();  // 標準エラーの読み取り開始

標準出力・標準エラーのデッドロックを避けたい場合、この非同期読み取りパターンが実務ではよく使われます。

9-5. async/awaitで外部コマンドを安全に実行する実装例

標準出力・標準エラーを非同期で取得し、タイムアウトにも対応した実装例です。

C#
using System.Diagnostics;
using System.Text;

public record ProcessResult(
    int ExitCode,
    string StandardOutput,
    string StandardError
);

public static async Task<ProcessResult> RunProcessAsync(
    string fileName,
    IEnumerable<string> arguments,
    int timeoutMilliseconds = 30000,
    CancellationToken cancellationToken = default)
{
    var outputBuilder = new StringBuilder();
    var errorBuilder = new StringBuilder();

    var startInfo = new ProcessStartInfo
    {
        FileName = fileName,
        UseShellExecute = false,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        CreateNoWindow = true,
        StandardOutputEncoding = Encoding.UTF8,
        StandardErrorEncoding = Encoding.UTF8
    };

    foreach (var arg in arguments)
    {
        startInfo.ArgumentList.Add(arg);
    }

    using var process = new Process
    {
        StartInfo = startInfo,
        EnableRaisingEvents = true
    };

    process.OutputDataReceived += (_, e) =>
    {
        if (e.Data != null)
        {
            outputBuilder.AppendLine(e.Data);
        }
    };

    process.ErrorDataReceived += (_, e) =>
    {
        if (e.Data != null)
        {
            errorBuilder.AppendLine(e.Data);
        }
    };

    process.Start();
    process.BeginOutputReadLine();
    process.BeginErrorReadLine();

    using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
    timeoutCts.CancelAfter(timeoutMilliseconds);

    try
    {
        await process.WaitForExitAsync(timeoutCts.Token);
    }
    catch (OperationCanceledException)
    {
        if (!process.HasExited)
        {
            process.Kill(entireProcessTree: true);
        }

        throw new TimeoutException($"Process timed out: {fileName}");
    }

    return new ProcessResult(
        process.ExitCode,
        outputBuilder.ToString(),
        errorBuilder.ToString()
    );
}

呼び出し例です。

C#
var result = await RunProcessAsync(
    "ping",
    new[] { "example.com" },
    timeoutMilliseconds: 10000
);

Console.WriteLine(result.StandardOutput);
Console.WriteLine(result.StandardError);
Console.WriteLine(result.ExitCode);

このように共通メソッド化しておくと、外部プロセス実行を安全かつ再利用しやすく管理できます。

10. よく使う実践サンプル

10-1. pingコマンドを実行して結果を取得する

C#
using System.Diagnostics;
using System.Text;

var startInfo = new ProcessStartInfo
{
    FileName = "ping",
    Arguments = "example.com",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true,
    StandardOutputEncoding = Encoding.UTF8,
    StandardErrorEncoding = Encoding.UTF8
};

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

Console.WriteLine(output);

if (process.ExitCode != 0)
{
    Console.Error.WriteLine(error);
}

Windowsで回数を指定する場合は-nを使います。

C#
Arguments = "-n 4 example.com";

LinuxやmacOSでは-cを使います。

C#
Arguments = "-c 4 example.com";

OSによってコマンド引数が異なる点に注意しましょう。

10-2. PowerShellコマンドをC#から実行する

PowerShellを実行する例です。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "powershell.exe",
    Arguments = "-NoProfile -ExecutionPolicy Bypass -Command \"Get-Date\"",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true
};

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

Console.WriteLine(output);
Console.WriteLine(error);

PowerShell 7以降のpwshを使う場合は、FileNameを変更します。

C#
FileName = "pwsh";

引数にユーザー入力を含める場合は、文字列連結ではなくArgumentListを使う方が安全です。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "pwsh",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true
};

startInfo.ArgumentList.Add("-NoProfile");
startInfo.ArgumentList.Add("-Command");
startInfo.ArgumentList.Add("Get-Date");

10-3. バッチファイルを起動する

バッチファイルを起動する例です。

C#
var startInfo = new ProcessStartInfo
{
    FileName = @"C:\Scripts\sample.bat",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true,
    WorkingDirectory = @"C:\Scripts"
};

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

Console.WriteLine(output);
Console.WriteLine(error);

cmd.exe経由で実行する場合は次のようにします。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "cmd.exe",
    Arguments = "/c \"C:\\Scripts\\sample.bat\"",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true
};

パスにスペースがある場合は引用符で囲む必要があります。

10-4. PythonやNode.jsなど外部プログラムを実行する

Pythonスクリプトを実行する例です。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "python",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true
};

startInfo.ArgumentList.Add("script.py");
startInfo.ArgumentList.Add("arg1");

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

Console.WriteLine(output);
Console.WriteLine(error);

Node.jsを実行する例です。

C#
var startInfo = new ProcessStartInfo
{
    FileName = "node",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true
};

startInfo.ArgumentList.Add("app.js");
startInfo.ArgumentList.Add("--mode");
startInfo.ArgumentList.Add("production");

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

Console.WriteLine(output);
Console.WriteLine(error);

PythonやNode.jsがPATHに通っていない場合は、FileNameにフルパスを指定します。

C#
FileName = @"C:\Python312\python.exe";

10-5. 実行結果をファイルに保存する

外部コマンドの結果をファイルに保存する例です。

C#
using System.Diagnostics;
using System.Text;

var startInfo = new ProcessStartInfo
{
    FileName = "ipconfig",
    Arguments = "/all",
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true,
    StandardOutputEncoding = Encoding.GetEncoding(932),
    StandardErrorEncoding = Encoding.GetEncoding(932)
};

using var process = Process.Start(startInfo);

string output = process!.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();

process.WaitForExit();

File.WriteAllText("result.txt", output, Encoding.UTF8);

if (!string.IsNullOrWhiteSpace(error))
{
    File.WriteAllText("error.txt", error, Encoding.UTF8);
}

実行結果をログとして残す場合は、終了コード、実行コマンド、開始時刻、終了時刻も一緒に記録するとトラブルシューティングしやすくなります。

11. Processクラスでよくあるエラーと対処法

11-1. 「指定されたファイルが見つかりません」の原因

このエラーは、FileNameに指定した実行ファイルが見つからないときに発生します。

主な原因は次の通りです。

• 実行ファイル名のスペルミス

• PATHが通っていない

• 作業ディレクトリの勘違い

• 相対パスの基準が想定と違う

• 32bit/64bit環境の違い

• UseShellExecute=falseでファイルやURLを開こうとしている

対処法として、まずフルパスで指定します。

C#
var startInfo = new ProcessStartInfo
{
    FileName = @"C:\Windows\System32\notepad.exe",
    UseShellExecute = false
};