如何在.NET Core CLI工具中可靠终止CMD启动的Node.js进程

Got it, let's work through building this .NET Console CLI tool to add end-to-end testing to your pipeline—here's a step-by-step breakdown that addresses all your requirements, including the tricky part of reliably killing Node.js processes started via CMD.

First, let's align on what we need this CLI to do:

• Act as an orchestrator for three Node.js/npm processes: backend service, frontend service, and end-to-end tests
• Gracefully terminate the backend and frontend services after tests complete
• Solve the reliability issue of killing Node.js processes launched via CMD
• Return an exit code of 0 when everything completes successfully

1. Set Up the .NET Console App Framework #

Start by creating a new .NET Console project:

dotnet new console -n E2ETestOrchestrator
cd E2ETestOrchestrator

You'll rely on the System.Diagnostics namespace for process management—no extra NuGet packages needed for core functionality (unless you want to add logging, but that's optional).

2. Launch and Monitor Processes #

Write logic to start each process, configure their execution contexts, and wait for the test process to finish. Here's a simplified code snippet:

using System.Diagnostics;

var backendProcess = StartProcess(@"C:\path\to\backend", "cmd.exe", "/c npm start");
var frontendProcess = StartProcess(@"C:\path\to\frontend", "cmd.exe", "/c npm start");
var testProcess = StartProcess(@"C:\path\to\tests", "cmd.exe", "/c npm run e2e");

// Wait for tests to finish
testProcess.WaitForExit();

// Clean up services regardless of test outcome
TerminateProcessTree(backendProcess);
TerminateProcessTree(frontendProcess);

// Return appropriate exit code
Environment.Exit(testProcess.ExitCode == 0 ? 0 : testProcess.ExitCode);

// Helper method to start processes
Process StartProcess(string workingDir, string fileName, string arguments)
{
    var process = new Process
    {
        StartInfo = new ProcessStartInfo
        {
            FileName = fileName,
            Arguments = arguments,
            WorkingDirectory = workingDir,
            UseShellExecute = false,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            CreateNoWindow = true // Optional: run in background
        }
    };
    process.Start();
    return process;
}

3. Reliably Terminate CMD-Launched Node.js Processes #

The biggest challenge here is that if you just kill the parent CMD process, its child Node.js process might keep running. We need to terminate the entire process tree:

Option 1: Use .NET's Built-in Kill(true) (Recommended for .NET Core 3.0+) #

.NET Core 3.0 introduced an overload of Process.Kill() that kills the process and all its child processes:

void TerminateProcessTree(Process process)
{
    if (!process.HasExited)
    {
        try
        {
            process.Kill(true); // Kills process and all children
            process.WaitForExit(5000); // Give it 5 seconds to exit gracefully
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error terminating process: {ex.Message}");
        }
    }
}

Option 2: Use taskkill for Older .NET Versions #

If you're stuck on an older .NET version, use the Windows taskkill command with the /T flag (terminate process tree) and /F (force termination):

void TerminateProcessTree(Process process)
{
    if (!process.HasExited)
    {
        var killCmd = new Process
        {
            StartInfo = new ProcessStartInfo
            {
                FileName = "taskkill.exe",
                Arguments = $"/PID {process.Id} /T /F",
                UseShellExecute = false,
                RedirectStandardOutput = true
            }
        };
        killCmd.Start();
        killCmd.WaitForExit();
    }
}

4. Exit Code Handling #

As shown in the core logic above:

• If the test process exits with 0 (success), we clean up services and return 0 from the CLI
• If tests fail (non-zero exit code), we still clean up services but pass through the test process's exit code so your pipeline can detect the failure

• Add logging to track process start/exit events and errors—this will help debug pipeline issues
• Add retries for process termination if needed (e.g., if a service takes time to shut down)
• Test the orchestrator locally first to ensure processes start and terminate correctly before adding it to your pipeline

内容的提问来源于stack exchange，提问作者Igor Soloydenko