启动cmd执行命令后，StandardOutput.ReadToEnd()返回空字符串求助

Hey there, let's figure out why you're getting empty output from your cmd.exe process. This is a common issue with a few straightforward fixes—let's break them down:

1. You're Missing the /c Switch for cmd.exe #

The biggest culprit here is almost certainly not using the /c parameter when launching cmd.exe. Without it, cmd.exe just starts an interactive shell (even though you can't see it with CreateNoWindow=true) and never actually runs your command. You need to tell cmd to execute the command and exit using /c.

Corrected ProcessStartInfo Setup #

string command = "your-actual-command-here";
ProcessStartInfo PSI = new ProcessStartInfo("cmd.exe", $"/c \"{command}\"");
PSI.UseShellExecute = false;
PSI.CreateNoWindow = true;
PSI.RedirectStandardInput = true; // Only needed if you're sending input to the process
PSI.RedirectStandardOutput = true;
PSI.RedirectStandardError = true; // Always redirect this too to catch errors

2. Ensure You Read Output After the Process Exits (Or Handle Async) #

If you try to read StandardOutput before the process has finished running, you might get an empty string. Always call WaitForExit() first, or use async methods to read output as it's generated.

Synchronous Approach (Blocking) #

using (Process process = Process.Start(PSI))
{
    // Wait for the process to finish executing
    process.WaitForExit();
    
    // Read both standard output and error streams
    string output = process.StandardOutput.ReadToEnd();
    string error = process.StandardError.ReadToEnd();
    
    // Use the output/error as needed
    Console.WriteLine("Command Output: " + output);
    Console.WriteLine("Command Errors: " + error);
}

Asynchronous Approach (Non-Blocking) #

If you don't want to block your main thread, use async event handlers to read streams in real-time:

using (Process process = new Process())
{
    process.StartInfo = PSI;
    
    // Attach event handlers for output and error
    process.OutputDataReceived += (sender, e) => 
    {
        if (!string.IsNullOrEmpty(e.Data))
        {
            Console.WriteLine("Live Output: " + e.Data);
        }
    };
    process.ErrorDataReceived += (sender, e) => 
    {
        if (!string.IsNullOrEmpty(e.Data))
        {
            Console.WriteLine("Live Error: " + e.Data);
        }
    };
    
    process.Start();
    // Start asynchronous reading of streams
    process.BeginOutputReadLine();
    process.BeginErrorReadLine();
    
    process.WaitForExit();
}

3. Check if Your Command Writes to Standard Error Instead of Output #

Some commands might write their output to stderr instead of stdout (though this is less common). By redirecting and reading StandardError, you'll catch that output instead of missing it entirely.

4. Avoid Deadlocks with Stream Reading Order #

If you read StandardOutput before StandardError (or vice versa) without waiting for the process to exit, you can hit a deadlock. The process might wait for your app to read one stream while your app waits for the other. Using WaitForExit() first (as in the synchronous example) avoids this, and async reading handles it automatically.

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