Как: Выполнить командную строку в C #, получить результаты STD OUT

Question

Как мне запустить программу командной строки из C # и получить результаты STD OUT? В частности, я хочу выполнить DIFF для двух файлов, которые программно выбраны, и записать результаты в текстовое поле.

Answer 1

// 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";
 p.Start();
 // 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();
 p.WaitForExit();

Код от MSDN .

Answer 2

Вот быстрый пример:

//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;   

//Optional
pProcess.StartInfo.WorkingDirectory = strWorkingDirectory;

//Start the process
pProcess.Start();

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

//Wait for process to finish
pProcess.WaitForExit();

Answer 3

Есть еще один параметр, который я нашел полезным, который я использую для исключения окна процесса

pProcess.StartInfo.CreateNoWindow = true;

это помогает полностью скрыть черное окно консоли от пользователя, если вы этого хотите.

Answer 4

// 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;
    try
    {
        process.Start();
        process.BeginOutputReadLine();
        stdError = process.StandardError.ReadToEnd();
        process.WaitForExit();
    }
    catch (Exception e)
    {
        throw new Exception("OS error while executing " + Format(filename, arguments)+ ": " + e.Message, e);
    }

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

        if (!string.IsNullOrEmpty(stdError))
        {
            message.AppendLine(stdError);
        }

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

        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) +
        "'";
}

Answer 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;
 proc.WaitForExit(2000);
 if (proc.HasExited)
  {
  string output = myOutput.ReadToEnd();
 }

Answer 6

Принятый ответ на этой странице имеет слабость, которая вызывает проблемы в редких ситуациях. Существует два дескриптора файла, в которые программы пишут по соглашению: stdout и stderr. Если вы просто прочитаете один дескриптор файла, такой как ответ от Ray, и программа, которую вы запускаете, записывает достаточно вывода в stderr, она заполнит буфер вывода stderr и заблокирует его. Тогда ваши два процесса зашли в тупик. Размер буфера может быть 4K. Это очень редко встречается в короткоживущих программах, но если у вас есть долго работающая программа, которая постоянно выводит в stderr, это произойдет в конце концов. Это сложно отладить и отследить.

Есть несколько хороших способов справиться с этим.

1. Один из способов - запустить cmd.exe вместо вашей программы и использовать аргумент / c для cmd.exe, чтобы вызвать вашу программу вместе с аргументом «2> & 1» для cmd.exe, чтобы он слился стандартный вывод и стандартный вывод

           var p = new Process();
           p.StartInfo.FileName = "cmd.exe";
           p.StartInfo.Arguments = "/c mycmd.exe 2>&1";
   

2. Другим способом является использование модели программирования, которая читает обе ручки одновременно.

           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);
           p.Start();
           p.BeginErrorReadLine();
           p.BeginOutputReadLine();
           p.WaitForExit();
   

Answer 7

Вам нужно будет использовать ProcessStartInfo с включенным RedirectStandardOutput - тогда вы сможете прочитать поток вывода. Возможно, вам будет проще использовать «>», чтобы перенаправить вывод в файл (через ОС), а затем просто прочитать файл.

[редактировать: как то, что сделал Рэй: +1]

Answer 8

Если вы не возражаете против введения зависимости, CliWrap может упростить это для вас:

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

Answer 9

Это может быть полезно для кого-то, если вы пытаетесь запросить локальный ARP-кэш на ПК / сервере.

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";
            p.Start();

            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[]
                {
                   lineArr[0],
                   lineArr[1],
                   lineArr[2]
                };
                    results.Add(arrResult);
                }
            }

            p.WaitForExit();
        }

Answer 10

Вы можете запустить любую программу командной строки, используя класс Process, и установить свойство StandardOutput экземпляра Process с помощью созданного вами средства чтения потоков (на основе строки или расположения в памяти). После завершения процесса вы можете делать в этом потоке все, что вам нужно.