C# 中如何更省心地运行外部命令并处理输入输出?

在 C# 中直接使用原生的 Process 类调用外部命令较为繁琐,处理输入输出时也容易踩坑。本文介绍 SimpleExec 这个第三方库,来应对轻量命令执行的场景。

平时做开发的时候,我们经常需要跟外部命令行程序打交道,比如调用系统命令、跑一段脚本,或者借助现成的 CLI 工具干活。

在 C# 中,标准库为我们提供了 System.Diagnostics.Process 类来启动外部进程并接管它的输入输出。比如说我们想调用 FFmpeg 来转换一个视频文件,最原生的写法大概长这样:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
using System.Diagnostics;

var process = new Process();
process.StartInfo.FileName = "ffmpeg";
process.StartInfo.Arguments = "-i input.webm output.mp4";
process.StartInfo.RedirectStandardInput = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.UseShellExecute = false;
process.Start();
process.StandardInput.Close();
string output = process.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();
process.WaitForExit();

或者我们也可以先单独构造一个 ProcessStartInfo 对象,利用对象初始化器把配置写得稍微紧凑一点:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var startInfo = new ProcessStartInfo
{
    FileName = "ffmpeg",
    Arguments = "-i input.webm output.mp4",
    RedirectStandardInput = true,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    UseShellExecute = false
};
var process = Process.Start(startInfo);
process.StandardInput.Close();
string output = process.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();
process.WaitForExit();

但这也未免太啰嗦了。明明只是想跑一条简单的命令,却每次都要写这么一大堆样板代码。就算我们自己动手把它封装成一个工具方法,真到了要处理异步读取、错误捕获、超时取消和流式交互的时候,里面藏着的坑也一点都不少,心智负担依然很重。

既然已经有成熟的轮子,我们就没必要自己折腾原生的 Process 了。这里,我想和大家分享几个非常好用的第三方库,看看它们是如何帮我们省心省力地调用外部命令、处理输入输出的。这篇文章我们先介绍第一个:SimpleExec。

SimpleExec

首先来看 SimpleExec。正如它的名字一样,这是一个对 Process 做了轻量级封装的小库。它的设计非常纯粹,核心 API 基本上就两组:只想把命令跑起来,就用 Run 或 RunAsync;想顺便把命令输出的文本拿回来,就用 ReadAsync。

我们可以通过 NuGet 直接安装它:

1
dotnet add package SimpleExec

执行命令

还是以前面的视频转换为例,换用 SimpleExec 之后,一行代码就搞定了:

1
2
3
using SimpleExec;

await Command.RunAsync("ffmpeg", "-i input.webm output.mp4");

是不是清爽多了?RunAsync 会帮我们启动进程并异步等待它结束,不用再手动调 Start、WaitForExit,也不用自己操心 Process 对象的释放。如果你写的只是一段简单的同步代码,也可以直接用同步版本 Command.Run:

1
Command.Run("ffmpeg", "-i input.webm output.mp4");

这种方式会看到真的启动了一个终端,并执行了相关的指令,随后终端自动退出。而我们自己的控制台程序只能够看到当前调用的完整命令。如果我们既不希望看到完整命令,也不希望看到弹窗,可以添加两个参数:

1
2
3
4
5
await Command.RunAsync(
    "ffmpeg",
    "-i input.webm output.mp4",
    noEcho: true,
    createNoWindow: true);

平时手动拼接命令行参数时,如果遇到空格,或一些需要转义的字符,最好不要自行处理。这时我们可以使用接收参数列表的重载,把每个参数拆开传进去:

1
2
3
await Command.RunAsync(
    "ffmpeg",
    new[] { "-i", "my input.webm", "my output.mp4" }); // 还可以使用集合表达式

这种写法在底层用的是 ProcessStartInfo.ArgumentList,集合里的每一项都会被当作一个独立的参数处理,完全不用我们自己再去拼引号。平时如果参数里包含变量或者用户传入的文件路径,更推荐这种写法。

获取标准输出和标准错误

如果我们需要拿到外部程序的输出结果,并在代码里做进一步解析,这时候可以使用 ReadAsync(没有同步的版本)。比如我们想用 FFprobe 读取视频文件的元数据:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
var (output, error) = await Command.ReadAsync(
    "ffprobe",
    new[]
    {
        "-v", "error",
        "-show_format",
        "-show_streams",
        "-of", "json",
        "input.webm"
    });

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

可以看到,ReadAsync 直接返回了一个包含标准输出和标准错误的元组。在这里,output 就是 FFprobe 输出的 JSON 字符串,而 error 拿到的则是标准错误里的诊断信息。

与 RunAsync 不同,ReadAsync 会在后台接管两个输出流并异步读取,等进程结束后再一次性返回完整文本,执行期间不会弹窗,也不会回显执行的命令。

Warning

文章开头演示原生 Process 用法时,连续调用了两次同步的 ReadToEnd()。实际项目中这样写存在死锁风险:一旦子进程写满标准错误的缓冲区,就会阻塞等待读取,而父进程此时还在等待标准输出结束,两边便会一直卡住。

自行封装 Process 时需要并发读取标准输出和标准错误,而 SimpleExec 的 ReadAsync 已经在内部处理好了这一点。

另外需要注意,error 中有内容并不一定代表命令执行失败。像 FFmpeg、Git 这类工具,经常会把正常的运行日志或进度信息输出到标准错误(stderr)中。判断命令是否成功,应当以退出码为准。

写入标准输入

除了读取输出,ReadAsync 还支持通过 standardInput 参数向子进程的标准输入写入一段文本。比如让 Git 直接计算一段字符串的哈希值:

1
2
3
4
5
6
var (hash, _) = await Command.ReadAsync(
    "git",
    new[] { "hash-object", "--stdin" },
    standardInput: "Hello, SimpleExec!\n");

Console.WriteLine(hash.Trim());

SimpleExec 在写入这段文本后会自动关闭标准输入流,通知子进程输入已经结束。

不难看出,这种方式只适合一次性传入文本的简单场景。如果遇到需要根据输出反复交互的命令行程序,或者需要持续传入流式数据,单靠这个参数就不够用了,这部分留到后文再谈。

配置工作目录和环境变量

执行外部命令时,经常还需要指定工作目录,或者临时配置几个环境变量。SimpleExec 对此提供了 workingDirectory 和 configureEnvironment 参数:

1
2
3
4
5
6
7
8
9
await Command.RunAsync(
    "dotnet",
    new[] { "build", "-c", "Release" },
    workingDirectory: @"C:\Projects\MyApp",
    configureEnvironment: environment =>
    {
        environment["DOTNET_CLI_UI_LANGUAGE"] = "en-US";
        environment["DOTNET_NOLOGO"] = "true";
    });

configureEnvironment 修改的只是当前子进程的环境变量,不会影响宿主进程和系统环境,未修改的变量则会默认从当前进程继承。此外,如果 ReadAsync 读取到的文本出现乱码,还可以通过 encoding 参数手动指定编码。

处理退出码和异常

按照命令行工具的惯例,退出码为 0 代表执行成功,非零则代表出错。因此一旦进程以非零退出码结束,Run 和 RunAsync 默认就会直接抛出 ExitCodeException 异常,省去了手动检查 ExitCode 的步骤。

而 ReadAsync 抛出的则是继承自它的 ExitCodeReadException,除了退出码之外,还一并保留了标准输出和标准错误的内容,便于排查问题:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
try
{
    var (output, _) = await Command.ReadAsync(
        "ffprobe",
        new[] { "-v", "error", "-show_format", "input.webm" });

    Console.WriteLine(output);
}
catch (ExitCodeReadException ex)
{
    Console.Error.WriteLine($"命令执行失败,退出码:{ex.ExitCode}");
    Console.Error.WriteLine(ex.StandardOutput);
    Console.Error.WriteLine(ex.StandardError);
}

不过并不是所有非零退出码都代表执行失败。比如 git diff --exit-code 在检测到差异时会返回 1,这往往正是期望检查的结果。遇到这类情况,可以通过 handleExitCode 自定义判断逻辑:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
int exitCode = 0;

await Command.RunAsync(
    "git",
    new[] { "diff", "--exit-code" },
    handleExitCode: code =>
    {
        exitCode = code;
        return code == 0 || code == 1;
    });

Console.WriteLine(exitCode == 1 ? "存在未暂存的差异" : "没有未暂存的差异");

handleExitCode 返回 true 表示该退出码视为正常,不再抛出异常;返回 false 则维持默认的抛异常行为。上面的代码放行了 0 和 1,遇到其他错误码时依然会正常报错。

取消执行和设置超时

对于视频压制、项目编译这类耗时较长的任务,通常还需要支持中途取消或超时控制。SimpleExec 的异步方法均支持传入 CancellationToken,配合 CancellationTokenSource 即可实现超时限制:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(2));

try
{
    await Command.RunAsync(
        "ffmpeg",
        new[] { "-nostdin", "-i", "input.webm", "output.mp4" },
        ct: timeout.Token);
}
catch (OperationCanceledException) when (timeout.IsCancellationRequested)
{
    Console.WriteLine("视频转换已超时取消。");
}

触发取消时,SimpleExec 会直接强行终止目标进程及其派生的子进程树。由于并非通知外部程序自行收尾退出,像 FFmpeg 这类工具被取消后可能会留下未写完的输出文件。

SimpleExec 的局限性

对于编写构建脚本、开发小工具,或是在应用中偶尔调用一次外部程序来说,SimpleExec 已经足够趁手,几行代码就能把常见的需求处理妥当。

它最大的短板在于不支持流式输出。RunAsync 拿不到输出内容,ReadAsync 又必须等进程完全结束后才一次性返回完整字符串。如果希望一边运行一边逐行读取输出(比如在 WPF 或 Avalonia UI 应用中实时解析 FFmpeg 的转码进度),或者直接通过 Stream 读写二进制数据与大体积内容,SimpleExec 就无能为力了。

此外,它也不支持管道(Pipe)等更灵活的输入输出组合。比如无法像命令行里的 cmdA | cmdB 那样将一个进程的输出直接接到另一个进程的输入,输入端也只能通过 standardInput 一次性传入一段字符串。

遇到这类场景时,就可以考虑接下来要介绍的第二个库:CliWrap。它的功能更加强大且全面。在下一篇中,我们会继续这一话题,来介绍如何使用 CliWrap 实现流式输出、管道组合以及更复杂的进程交互。

使用 Hugo 构建
主题 Stack 由 Jimmy 设计