C#启动Node.js进程执行依赖npm包的JavaScript脚本

在企业级开发或桌面应用中，我们偶尔会遇到.NET生态难以快速解决但Node.js生态拥有成熟库的场景，例如利用Puppeteer进行网页无头渲染生成PDF、调用特定加密算法库或基于复杂AST转换语法。本文通过一个具体的应用情境切入，完整演示如何使用C#的System.Diagnostics.Process启动Node.js子进程，正确定位工作目录以解析项目内的node_modules依赖，捕获标准输出与错误流，并确保进程生命周期与异常的安全管理。

一、整体架构与进程交互原理

C#调用外部Node.js脚本的核心原理是通过操作系统层面的进程间管道（Pipes）进行通信。C#作为父进程负责构造命令行参数、配置环境变量与工作目录，拉起node可执行文件作为子进程。Node.js在执行JavaScript脚本时，其模块解析算法（CommonJS或ESM）依赖于当前执行上下文的文件路径或进程工作目录来向上递归查找node_modules文件夹。执行完毕后，脚本将结果写入标准输出（stdout），如果发生错误则写入标准错误（stderr），C#父进程通过异步或同步方式读取流内容并获取退出代码（ExitCode）。

图1：C# 启动 Node.js 子进程及环境绑定的体系架构示意图

二、准备工作：搭建包含npm依赖的Node.js工程

在开始编写C#代码前，必须先在磁盘上建立规范的Node.js执行目录，确保依赖包已通过npm正确安装。这里以安装流行的数学与工具库lodash和dayjs为例。

假设我们在项目目录下创建子文件夹node_scripts：

# 1. 创建并进入目录
mkdir node_scripts
cd node_scripts

# 2. 初始化 package.json
npm init -y

# 3. 安装依赖包
npm install lodash dayjs

随后编写供C#调用的脚本worker.js。脚本接收传入的参数或直接执行业务逻辑，最终将结构化结果通过console.log输出为JSON字符串：

// node_scripts/worker.js
const _ = require('lodash');
const dayjs = require('dayjs');

try {
    // 从命令行参数获取传入的数据（argv[2]是第一个用户参数）
    const inputArg = process.argv[2] || '{}';
    const inputData = JSON.parse(inputArg);

    // 使用 lodash 进行数组扁平化和去重处理
    const numbers = inputData.numbers || [1, [2, 3], [4, [5]], 3, 2];
    const uniqueSorted = _.chain(numbers)
        .flattenDeep()
        .uniq()
        .sortBy()
        .value();

    // 使用 dayjs 处理日期
    const formattedDate = dayjs().format('YYYY-MM-DD HH:mm:ss');

    const result = {
        success: true,
        processedAt: formattedDate,
        data: uniqueSorted
    };

    // 将结果写入标准输出
    console.log(JSON.stringify(result));
    process.exit(0);
} catch (err) {
    // 错误写入标准错误
    console.error(JSON.stringify({
        success: false,
        error: err.message,
        stack: err.stack
    }));
    process.exit(1);
}

三、核心操作流程：从C#启动子进程

要在C#中成功执行上述脚本，必须按顺序完成四个关键环节：定位可执行程序、配置ProcessStartInfo参数、重定向标准输入输出流、读取返回结果并安全等待退出。

图2：C# 调用外部 Node.js 脚本的完整执行流水线

四、C# 完整调用实现示例

下面给出基于.NET现代标准的完整实现代码。封装了一个独立方法ExecuteNodeScriptAsync，支持传递入参并安全解析结果：

using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading.Tasks;

namespace NodeProcessRunner
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // 脚本与Node目录的绝对路径，确保无路径歧义
            string projectBase = AppDomain.CurrentDomain.BaseDirectory;
            string scriptsDir = Path.GetFullPath(Path.Combine(projectBase, "..", "..", "..", "node_scripts"));
            string scriptFile = Path.Combine(scriptsDir, "worker.js");

            // 构造需要传递给JS脚本的JSON入参
            string jsonPayload = "{\"numbers\": [12, [5, 8], [12, [3, 5]], 99, 1]}";

            Console.WriteLine("正在启动 Node.js 子进程...");
            var (exitCode, stdout, stderr) = await RunNodeScriptAsync(scriptsDir, scriptFile, jsonPayload);

            if (exitCode == 0)
            {
                Console.WriteLine("执行成功！输出结果：");
                Console.WriteLine(stdout);
            }
            else
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"执行失败，ExitCode: {exitCode}");
                Console.WriteLine($"错误输出: {stderr}");
                Console.ResetColor();
            }
        }

        public static async Task<(int exitCode, string stdout, string stderr)> RunNodeScriptAsync(
            string workingDirectory,
            string scriptFilePath,
            string argumentJson)
        {
            if (!File.Exists(scriptFilePath))
            {
                throw new FileNotFoundException("未找到指定的JavaScript脚本文件", scriptFilePath);
            }

            // 处理参数中的转义双引号，避免命令行截断
            string escapedJson = argumentJson.Replace("\"", "\\\"");

            var startInfo = new ProcessStartInfo
            {
                FileName = "node", // 若node不在系统PATH中，可写入node绝对路径如 @"C:\Program Files\nodejs\node.exe"
                Arguments = $"\"{scriptFilePath}\" \"{escapedJson}\"",
                WorkingDirectory = workingDirectory, // 关键：指定node_modules所在目录
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
                CreateNoWindow = true,
                StandardOutputEncoding = Encoding.UTF8,
                StandardErrorEncoding = Encoding.UTF8
            };

            using var process = new Process { StartInfo = startInfo };

            var outputBuilder = new StringBuilder();
            var errorBuilder = new StringBuilder();

            // 注册异步事件，防止多流并发死锁
            process.OutputDataReceived += (sender, e) =>
            {
                if (e.Data != null) outputBuilder.AppendLine(e.Data);
            };
            process.ErrorDataReceived += (sender, e) =>
            {
                if (e.Data != null) errorBuilder.AppendLine(e.Data);
            };

            try
            {
                process.Start();

                // 开始异步读取
                process.BeginOutputReadLine();
                process.BeginErrorReadLine();

                // 异步等待进程结束，或设定超时逻辑
                await Task.Run(() => process.WaitForExit(30000)); // 30秒超时

                if (!process.HasExited)
                {
                    process.Kill(true); // 超时杀死进程树
                    throw new TimeoutException("Node.js 进程执行超时，已被强制终止");
                }

                return (process.ExitCode, outputBuilder.ToString().Trim(), errorBuilder.ToString().Trim());
            }
            catch (Exception ex)
            {
                return (-1, string.Empty, ex.Message);
            }
        }
    }
}

五、npm 依赖解析的关键机制对比

在实际部署中，最常见的问题是Error: Cannot find module 'lodash'。很多开发者误以为只要脚本写了require('lodash')，Node.js就能自动找到依赖。其实，Node.js严格遵循模块路径查找规则。

图3：工作目录配置对 Node.js 依赖寻址机制的影响对比

六、高频陷阱与生产调优建议

1. 死锁（Deadlock）陷阱： 当子进程产生大量输出时，操作系统缓冲区填满会导致子进程暂停执行，等待缓冲区被消费。如果C#代码使用同步方法且顺序调用process.StandardOutput.ReadToEnd()和process.WaitForExit()，可能引发双向等待死锁。因此，务必采用事件驱动（BeginOutputReadLine）或异步读取方式。
2. 编码与中文乱码： Windows控制台默认编码可能是GBK，而Node.js标准输出通常为UTF-8。如果直接读取容易出现中文字符乱码，必须显式在ProcessStartInfo中指定StandardOutputEncoding = Encoding.UTF8。
3. 长参数与命令行溢出： 命令行参数长度存在系统上限（Windows通常为8191或32768字符）。若传输的大型JSON超过此限制，应改为通过process.StandardInput写入管道流，或先将数据写入临时文件再传文件路径。
4. 跨平台路径兼容： 在Linux或macOS上部署时，node命令可直接通过PATH找到，但在Windows服务或IIS托管环境下，系统服务账户可能未包含全局PATH，推荐在配置文件中允许指定Node.js的完整路径。

七、总结

通过C#启动Node.js子进程，是在.NET工程中无缝复用前端npm生态能力的轻量方案。只要牢牢把握好进程参数、工作目录设置、管道流异步通信以及生命周期超时控制，就能在兼顾.NET严谨架构的同时，充分发挥现代Node.js生态的敏捷优势。

图4：C# 启动 Node.js 子进程核心知识体系全景总结