How To: Execute command line in C#, get STD OUT results

Wing Source

How do I execute a command-line program from C# and get back the STD OUT results. Specifically, I want to execute DIFF on two files that are programmatically selected and write the results to a text box. Yes, I could figure this out for myself, but surely someone else has done something like it and I'm lazy...



answered 10 years ago Kon #1

This may not be the best/easiest way, but may be an option:

When you execute from your code, add " > output.txt" and then read in the output.txt file.

answered 10 years ago Ray Jezek #2

// Start the child process.
 Process p = new Process();
 // Redirect the output stream of the child process.
 p.StartInfo.UseShellExecute = false;
 p.StartInfo.RedirectStandardOutput = true;
 p.StartInfo.FileName = "YOURBATCHFILE.bat";
 // Do not wait for the child process to exit before
 // reading to the end of its redirected stream.
 // p.WaitForExit();
 // Read the output stream first and then wait.
 string output = p.StandardOutput.ReadToEnd();

Code is from MSDN.

answered 10 years ago Marc Gravell #3

You will need to use ProcessStartInfo with RedirectStandardOutput enabled - then you can read the output stream. You might find it easier to use ">" to redirect the output to a file (via the OS), and then simply read the file.

[edit: like what Ray did: +1]

answered 10 years ago Nick #4

You can launch any command line program using the Process class, and set the StandardOutput property of the Process instance with a stream reader you create (either based on a string or a memory location). After the process completes, you can then do whatever diff you need to on that stream.

answered 10 years ago Jeff Mc #5

 System.Diagnostics.ProcessStartInfo psi =
   new System.Diagnostics.ProcessStartInfo(@"program_to_call.exe");
 psi.RedirectStandardOutput = true;
 psi.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
 psi.UseShellExecute = false;
 System.Diagnostics.Process proc System.Diagnostics.Process.Start(psi);;
 System.IO.StreamReader myOutput = proc.StandardOutput;
 if (proc.HasExited)
  string output = myOutput.ReadToEnd();

answered 10 years ago Jeremy #6

Here's a quick sample:

//Create process
System.Diagnostics.Process pProcess = new System.Diagnostics.Process();

//strCommand is path and file name of command to run
pProcess.StartInfo.FileName = strCommand;

//strCommandParameters are parameters to pass to program
pProcess.StartInfo.Arguments = strCommandParameters;

pProcess.StartInfo.UseShellExecute = false;

//Set output of program to be written to process output stream
pProcess.StartInfo.RedirectStandardOutput = true;   

pProcess.StartInfo.WorkingDirectory = strWorkingDirectory;

//Start the process

//Get program output
string strOutput = pProcess.StandardOutput.ReadToEnd();

//Wait for process to finish

answered 9 years ago Shaik #7

There is a ProcessHelper Class in PublicDomain open source code which might interest you.

answered 9 years ago Peter Du #8

There one other parameter I found useful, which I use to eliminate the process window

pProcess.StartInfo.CreateNoWindow = true;

this helps to hide the black console window from user completely, if that is what you desire.

answered 6 years ago Lu55 #9

// usage
const string ToolFileName = "example.exe";
string output = RunExternalExe(ToolFileName);

public string RunExternalExe(string filename, string arguments = null)
    var process = new Process();

    process.StartInfo.FileName = filename;
    if (!string.IsNullOrEmpty(arguments))
        process.StartInfo.Arguments = arguments;

    process.StartInfo.CreateNoWindow = true;
    process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
    process.StartInfo.UseShellExecute = false;

    process.StartInfo.RedirectStandardError = true;
    process.StartInfo.RedirectStandardOutput = true;
    var stdOutput = new StringBuilder();
    process.OutputDataReceived += (sender, args) => stdOutput.AppendLine(args.Data); // Use AppendLine rather than Append since args.Data is one line of output, not including the newline character.

    string stdError = null;
        stdError = process.StandardError.ReadToEnd();
    catch (Exception e)
        throw new Exception("OS error while executing " + Format(filename, arguments)+ ": " + e.Message, e);

    if (process.ExitCode == 0)
        return stdOutput.ToString();
        var message = new StringBuilder();

        if (!string.IsNullOrEmpty(stdError))

        if (stdOutput.Length != 0)
            message.AppendLine("Std output:");

        throw new Exception(Format(filename, arguments) + " finished with exit code = " + process.ExitCode + ": " + message);

private string Format(string filename, string arguments)
    return "'" + filename + 
        ((string.IsNullOrEmpty(arguments)) ? string.Empty : " " + arguments) +

answered 10 months ago Kitson88 #10

This might be useful for someone if your attempting to query the local ARP cache on a PC/Server.

List<string[]> results = new List<string[]>();

        using (Process p = new Process())
            p.StartInfo.CreateNoWindow = true;
            p.StartInfo.RedirectStandardOutput = true;
            p.StartInfo.UseShellExecute = false;
            p.StartInfo.Arguments = "/c arp -a";
            p.StartInfo.FileName = @"C:\Windows\System32\cmd.exe";

            string line;

            while ((line = p.StandardOutput.ReadLine()) != null)
                if (line != "" && !line.Contains("Interface") && !line.Contains("Physical Address"))
                    var lineArr = line.Trim().Split(' ').Select(n => n).Where(n => !string.IsNullOrEmpty(n)).ToArray();
                    var arrResult = new string[]


answered 8 months ago Alexey 'Tyrrrz' Golub #11

If you don't mind introducing a dependency, CliWrap can simplify this for you:

var cli = new Cli("target.exe");
var output = await cli.ExecuteAsync("arguments", "stdin");
var stdout = output.StandardOutput;

answered 7 months ago Cameron #12

The accepted answer on this page has a weakness that is troublesome in rare situations. There are two file handles which programs write to by convention, stdout, and stderr. If you just read a single file handle such as the answer from Ray, and the program you are starting writes enough output to stderr, it will fill up the output stderr buffer and block. Then your two processes are deadlocked. The buffer size may be 4K. This is extremely rare on short-lived programs, but if you have a long running program which repeatedly outputs to stderr, it will happen eventually. This is tricky to debug and track down.

There are a couple good ways to deal with this.

  1. One way is to execute cmd.exe instead of your program and use the /c argument to cmd.exe to invoke your program along with the "2>&1" argument to cmd.exe to tell it to merge stdout and stderr.

            var p = new Process();
            p.StartInfo.FileName = "cmd.exe";
            p.StartInfo.Arguments = "/c mycmd.exe 2>&1";
  2. Another way is to use a programming model which reads both handles at the same time.

            var p = new Process();
            p.StartInfo.FileName = "cmd.exe";
            p.StartInfo.Arguments = @"/c dir \windows";
            p.StartInfo.CreateNoWindow = true;
            p.StartInfo.RedirectStandardError = true;
            p.StartInfo.RedirectStandardOutput = true;
            p.StartInfo.RedirectStandardInput = false;
            p.OutputDataReceived += (a, b) => Console.WriteLine(b.Data);
            p.ErrorDataReceived += (a, b) => Console.WriteLine(b.Data);

answered 4 months ago Dave #13

Just for fun, here's my completed solution for getting PYTHON output - under a button click - with error reporting. Just add a button called "butPython" and a label called "llHello"...

    private void butPython(object sender, EventArgs e)
        llHello.Text = "Calling Python...";
        Tuple<String,String> python = GoPython(@"C:\Users\BLAH\Desktop\Code\Python\");
        llHello.Text = python.Item1; // Show result.
        if (python.Item2.Length > 0) MessageBox.Show("Sorry, there was an error:" + Environment.NewLine + python.Item2);

    public Tuple<String,String> GoPython(string pythonFile, string moreArgs = "")
        ProcessStartInfo PSI = new ProcessStartInfo();
        PSI.FileName = "py.exe";
        PSI.Arguments = string.Format("\"{0}\" {1}", pythonFile, moreArgs);
        PSI.CreateNoWindow = true;
        PSI.UseShellExecute = false;
        PSI.RedirectStandardError = true;
        PSI.RedirectStandardOutput = true;
        using (Process process = Process.Start(PSI))
            using (StreamReader reader = process.StandardOutput)
                string stderr = process.StandardError.ReadToEnd(); // Error(s)!!
                string result = reader.ReadToEnd(); // What we want.
                return new Tuple<String,String> (result,stderr); 

comments powered by Disqus