C#调用CMD命令偶发无响应，现有超时机制失效求解决方案

使用以下CommandExecutor类执行CMD命令时，即便设置了超时机制，生产服务器上仍偶尔出现无原因卡住的情况，需要分析原因并改进超时机制，确保卡住时系统能返回false。

原代码：

using System.Diagnostics;
using System.Text;

namespace SharedLibraries.Helpers
{

    public class CommandExecutor
    {
        private readonly Logger _logger;
        private const int DefaultTimeoutMilliseconds = 10000;
        public CommandExecutor(Logger logger)
        {
            _logger = logger;
        }
        public bool ExecuteCommand(string command, out string result, int timeoutMilliseconds = DefaultTimeoutMilliseconds)
        {
            Process? process = new()
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = "cmd.exe",
                    Arguments = $"/c {command}",
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    StandardOutputEncoding = Encoding.UTF8,
                    StandardErrorEncoding = Encoding.UTF8
                }
            };

            StringBuilder? output = new();
            StringBuilder? error = new();

            try
            {
                _logger.Log(message: $"Executing command: '{command}'", LogLevel.INFO);
                process.OutputDataReceived += (object sender, DataReceivedEventArgs args) => { output.AppendLine(args.Data); };
                process.ErrorDataReceived += (object sender, DataReceivedEventArgs args) => { error.AppendLine(args.Data); };

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

                if (!process.WaitForExit(milliseconds: timeoutMilliseconds))
                {
                    process.Kill();
                    result = "Command execution timed out.";
                    _logger.Log(message: $"Command timeout. Command: '{command}', Timeout: {timeoutMilliseconds}ms", LogLevel.ERROR);
                    return false;
                }

                process.WaitForExit();

                string errorOutput = error.ToString().Trim();
                if (process.ExitCode != 0 || !string.IsNullOrEmpty(value: errorOutput))
                {
                    result = $"Command execution failed with exit code {process.ExitCode}:\n{errorOutput}";
                    _logger.Log(message: $"Command execution failed. Command: '{command}', Exit Code: {process.ExitCode}, Error: {errorOutput}", LogLevel.ERROR);
                    return false;
                }

                result = output.ToString().Trim();
                _logger.Log(message: $"Command executed successfully. Command: '{command}', Result:\n{result}", LogLevel.INFO);
                return true;
            }
            catch (Exception ex)
            {
                result = $"Error executing command: {ex.Message}";
                _logger.Log(message: $"Exception during command execution. Command: '{command}', Exception: {ex}", LogLevel.ERROR);
                return false;
            }
        }
    }
}

• 异步流读取死锁：使用BeginOutputReadLine和BeginErrorReadLine时，子进程的输出/错误缓冲区被填满后会阻塞子进程执行，而父进程卡在WaitForExit调用中，双方互相等待导致死锁，超时机制完全失效。
• Process.Kill()无法彻底终止进程：Kill()仅能终止当前cmd.exe进程，若cmd启动了其他子进程，这些子进程不会被终止，可能占用资源导致父进程资源无法释放；此外，若进程处于内核态等待（如等待未响应的IO），Kill()可能无法立即终止进程，导致WaitForExit持续等待。
• 重复调用WaitForExit：代码中在WaitForExit(timeout)返回true后，又调用无参的WaitForExit()，属于冗余操作，且可能因进程状态异常引发不必要的等待。
• 命令参数未正确转义：用$"/c {command}"拼接参数时，若command包含空格、引号等特殊字符，会导致cmd.exe解析错误，进程可能卡住或执行异常。

针对上述问题，从流读取、进程终止、资源管理三个核心点优化：

1. 改用同步流读取+异步等待，避免异步流的死锁问题；
2. 实现进程树终止，确保cmd及其子进程都被清理；
3. 增加Kill后等待超时，避免无限等待进程终止；
4. 正确转义命令参数，避免解析错误；
5. 用using管理Process资源，确保资源及时释放。

改进后的代码：

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

namespace SharedLibraries.Helpers
{
    public class CommandExecutor
    {
        private readonly Logger _logger;
        private const int DefaultTimeoutMilliseconds = 10000;
        private const int KillWaitTimeoutMilliseconds = 2000; // Kill后等待进程退出的超时

        public CommandExecutor(Logger logger)
        {
            _logger = logger;
        }

        public bool ExecuteCommand(string command, out string result, int timeoutMilliseconds = DefaultTimeoutMilliseconds)
        {
            result = string.Empty;
            var outputBuilder = new StringBuilder();
            var errorBuilder = new StringBuilder();

            using var process = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = "cmd.exe",
                    Arguments = $"/c \"{command.Replace("\"", "\\\"")}\"", // 转义双引号，避免解析错误
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    StandardOutputEncoding = Encoding.UTF8,
                    StandardErrorEncoding = Encoding.UTF8
                }
            };

            try
            {
                _logger.Log($"Executing command: '{command}'", LogLevel.INFO);

                process.Start();

                // 异步读取输出和错误流，避免阻塞
                var readOutputTask = Task.Run(() =>
                {
                    string? line;
                    while ((line = process.StandardOutput.ReadLine()) != null)
                    {
                        outputBuilder.AppendLine(line);
                    }
                });

                var readErrorTask = Task.Run(() =>
                {
                    string? line;
                    while ((line = process.StandardError.ReadLine()) != null)
                    {
                        errorBuilder.AppendLine(line);
                    }
                });

                // 等待进程退出或超时
                if (!process.WaitForExit(timeoutMilliseconds))
                {
                    // 终止整个进程树
                    KillProcessTree(process.Id);
                    
                    // 等待Kill完成，避免资源泄漏
                    if (!process.WaitForExit(KillWaitTimeoutMilliseconds))
                    {
                        _logger.Log($"Failed to terminate process after timeout. Command: '{command}'", LogLevel.ERROR);
                    }

                    result = "Command execution timed out.";
                    _logger.Log($"Command timeout. Command: '{command}', Timeout: {timeoutMilliseconds}ms", LogLevel.ERROR);
                    return false;
                }

                // 等待流读取完成
                Task.WaitAll(readOutputTask, readErrorTask);

                var errorOutput = errorBuilder.ToString().Trim();
                if (process.ExitCode != 0 || !string.IsNullOrEmpty(errorOutput))
                {
                    result = $"Command execution failed with exit code {process.ExitCode}:\n{errorOutput}";
                    _logger.Log($"Command execution failed. Command: '{command}', Exit Code: {process.ExitCode}, Error: {errorOutput}", LogLevel.ERROR);
                    return false;
                }

                result = outputBuilder.ToString().Trim();
                _logger.Log($"Command executed successfully. Command: '{command}', Result:\n{result}", LogLevel.INFO);
                return true;
            }
            catch (Exception ex)
            {
                result = $"Error executing command: {ex.Message}";
                _logger.Log($"Exception during command execution. Command: '{command}', Exception: {ex}", LogLevel.ERROR);
                return false;
            }
        }

        // 终止进程树的辅助方法
        private void KillProcessTree(int processId)
        {
            try
            {
                using var searcher = new ManagementObjectSearcher($"SELECT * FROM Win32_Process WHERE ParentProcessId={processId}");
                foreach (var obj in searcher.Get())
                {
                    var childId = (uint)obj["ProcessId"];
                    if (childId != 0)
                    {
                        try
                        {
                            using var childProcess = Process.GetProcessById((int)childId);
                            KillProcessTree((int)childId);
                            if (!childProcess.HasExited)
                            {
                                childProcess.Kill();
                            }
                        }
                        catch (ArgumentException)
                        {
                            // 进程已退出，忽略
                        }
                    }
                }

                // 终止当前进程
                using var parentProcess = Process.GetProcessById(processId);
                if (!parentProcess.HasExited)
                {
                    parentProcess.Kill();
                }
            }
            catch (Exception ex)
            {
                _logger.Log($"Failed to kill process tree. ProcessId: {processId}, Exception: {ex}", LogLevel.ERROR);
            }
        }
    }
}

• 若无需通过cmd.exe执行命令（如直接调用可执行文件），可直接设置FileName为目标程序路径，Arguments为对应参数，避免cmd的解析问题；
• KillProcessTree方法需要引用System.Management程序集，若服务器环境无法引用，可改用taskkill /F /T /PID {processId}命令替代。

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