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

Question

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

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

532

c# command-line

Источник

user958 15 окт '08 в 20:31

18 ответов

Решение

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

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

167

Источник

user9266 15 окт '08 в 20:39

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

pProcess.StartInfo.CreateNoWindow = true;

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

116

Источник

user162429 28 сен '09 в 18:36

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

114

Источник

user355438 09 апр '12 в 10:45

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

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

Одним из способов является выполнение cmd.exe вместо вашей программы и использование аргумента /c для cmd.exe, чтобы вызвать вашу программу вместе с аргументом "2>&1" для cmd.exe, чтобы он сказал объединить stdout и stderr.
```
        var p = new Process();
        p.StartInfo.FileName = "cmd.exe";
        p.StartInfo.Arguments = "/c mycmd.exe 2>&1";
```

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

        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();

22

Источник

user86375 19 ноя '17 в 22:10

 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();
 }

13

Источник

user25521 15 окт '08 в 20:38

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

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

9

Источник

user2205454 29 окт '17 в 17:27

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

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

7

Источник

user23354 15 окт '08 в 20:36

Поскольку большинство ответов здесь не реализуют using государственный IDisposable и некоторые другие вещи, которые, как мне кажется, могут быть необходимы, я добавлю этот ответ.

Для C# 8.0

// Start a process with the filename or path with filename e.g. "cmd". Please note the 
//using statemant
using myProcess.StartInfo.FileName = "cmd";
// add the arguments - Note add "/c" if you want to carry out tge  argument in cmd and  
// terminate
myProcess.StartInfo.Arguments = "/c dir";
// Allows to raise events
myProcess.EnableRaisingEvents = true;
//hosted by the application itself to not open a black cmd window
myProcess.StartInfo.UseShellExecute = false;
myProcess.StartInfo.CreateNoWindow = true;
// Eventhander for data
myProcess.Exited += OnOutputDataRecived;
// Eventhandler for error
myProcess.ErrorDataReceived += OnErrorDataReceived;
// Eventhandler wich fires when exited
myProcess.Exited += OnExited;
// Starts the process
myProcess.Start();
//read the output before you wait for exit
myProcess.BeginOutputReadLine();
// wait for the finish - this will block (leave this out if you dont want to wait for 
// it, so it runs without blocking)
process.WaitForExit();

// Handle the dataevent
private void OnOutputDataRecived(object sender, DataReceivedEventArgs e)
{
    //do something with your data
    Trace.WriteLine(e.Data);
}

//Handle the error
private void OnErrorDataReceived(object sender, DataReceivedEventArgs e)
{        
    Trace.WriteLine(e.Data);
    //do something with your exception
    throw new Exception();
}    

// Handle Exited event and display process information.
private void OnExited(object sender, System.EventArgs e)
{
     Trace.WriteLine("Process exited");
}

6

Источник

user9479890 18 май '20 в 13:07

Вот небольшой пример:

      using System;
using System.Diagnostics;

class Program
{
    static void Main(string[] args)
    {
        var p = Process.Start(
            new ProcessStartInfo("git", "branch --show-current")
            {
                CreateNoWindow = true,
                UseShellExecute = false,
                RedirectStandardError = true,
                RedirectStandardOutput = true,
                WorkingDirectory = Environment.CurrentDirectory
            }
        );

        p.WaitForExit();
        string branchName =p.StandardOutput.ReadToEnd().TrimEnd();
        string errorInfoIfAny =p.StandardError.ReadToEnd().TrimEnd();

        if (errorInfoIfAny.Length != 0)
        {
            Console.WriteLine($"error: {errorInfoIfAny}");
        }
        else { 
            Console.WriteLine($"branch: {branchName}");
        }

    }
}

Я считаю, что это самая короткая форма.

Обратите внимание, что большинство инструментов командной строки легко путают стандартный вывод и стандартную ошибку, иногда имеет смысл просто объединить их в одну строку.

Также иногда может быть полезно.

6

Источник

user2338477 25 мар '21 в 14:13

Если вам также нужно выполнить какую-то команду в cmd.exe, вы можете сделать следующее:

// 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 = "cmd.exe";
p.StartInfo.Arguments = "/C vol";
p.Start();
// Read the output stream first and then wait.
string output = p.StandardOutput.ReadToEnd();
p.WaitForExit();
Console.WriteLine(output);

Это возвращает только вывод самой команды:

ht tps:https://stackru.com/images/00aefd4ccad8d005852782a77bcacaacb5ad2879.png

Вы также можете использовать StandardInput вместо того StartInfo.Arguments:

// Start the child process.
Process p = new Process();
// Redirect the output stream of the child process.
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardInput = true;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.FileName = "cmd.exe";
p.Start();
// Read the output stream first and then wait.
p.StandardInput.WriteLine("vol");
p.StandardInput.WriteLine("exit");
string output = p.StandardOutput.ReadToEnd();
p.WaitForExit();
Console.WriteLine(output);

Результат выглядит так:

ht tps:https://stackru.com/images/aa846f9611d2a8e923d64d9bafe962eb563407a2.png

5

Источник

user710069 30 янв '20 в 16:48

Однострочная команда запуска:

new Process() { StartInfo = new ProcessStartInfo("echo", "Hello, World") }.Start();

Прочтите вывод команды в кратчайшие сроки действующего кода:

    var cliProcess = new Process() {
        StartInfo = new ProcessStartInfo("echo", "Hello, World") {
            UseShellExecute = false,
            RedirectStandardOutput = true
        }
    };
    cliProcess.Start();
    string cliOut = cliProcess.StandardOutput.ReadToEnd();
    cliProcess.WaitForExit();
    cliProcess.Close();

5

Источник

user660896 08 окт '19 в 15:44

Это может быть не самым лучшим / простым способом, но может быть вариантом:

Когда вы выполняете из своего кода, добавьте " > output.txt" и затем прочитайте в файле output.txt.

3

Источник

user22303 15 окт '08 в 20:35

Это может быть полезно для кого-то, если вы пытаетесь запросить локальный 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();
        }

3

Источник

user6574422 22 авг '17 в 12:14

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

3

Источник

user22407 15 окт '08 в 20:37

Существует класс ProcessHelper в открытом исходном коде PublicDomain, который может вас заинтересовать.

2

Источник

user7637 12 авг '09 в 13:17

Решение Джулиана протестировано и работает с небольшими исправлениями. Ниже приведен пример, в котором также используются https://sourceforge.net/projects/bat-to-exe/ GenericConsole.cs и https://www.codeproject.com/Articles/19225/Bat-file-compiler program.txt. для части args:

using System;
using System.Text;  //StringBuilder
using System.Diagnostics;
using System.IO;


class Program
{
    private static bool redirectStandardOutput = true;

    private static string buildargument(string[] args)
    {
        StringBuilder arg = new StringBuilder();
        for (int i = 0; i < args.Length; i++)
        {
            arg.Append("\"" + args[i] + "\" ");
        }

        return arg.ToString();
    }

    static void Main(string[] args)
    {
        Process prc = new Process();
        prc.StartInfo = //new ProcessStartInfo("cmd.exe", String.Format("/c \"\"{0}\" {1}", Path.Combine(Environment.CurrentDirectory, "mapTargetIDToTargetNameA3.bat"), buildargument(args)));
        //new ProcessStartInfo(Path.Combine(Environment.CurrentDirectory, "mapTargetIDToTargetNameA3.bat"), buildargument(args));
        new ProcessStartInfo("mapTargetIDToTargetNameA3.bat");
        prc.StartInfo.Arguments = buildargument(args);

        prc.EnableRaisingEvents = true;

        if (redirectStandardOutput == true)
        {
            prc.StartInfo.UseShellExecute = false;
        }
        else
        {
            prc.StartInfo.UseShellExecute = true;
        }

        prc.StartInfo.CreateNoWindow = true;

        prc.OutputDataReceived += OnOutputDataRecived;
        prc.ErrorDataReceived += OnErrorDataReceived;
        //prc.Exited += OnExited;

        prc.StartInfo.RedirectStandardOutput = redirectStandardOutput;
        prc.StartInfo.RedirectStandardError = redirectStandardOutput;

        try
        {
            prc.Start();
            prc.BeginOutputReadLine();
            prc.BeginErrorReadLine();
            prc.WaitForExit();
        }
        catch (Exception e)
        {
            Console.WriteLine("OS error: " + e.Message);
        }

        prc.Close();
    }

    // Handle the dataevent
    private static void OnOutputDataRecived(object sender, DataReceivedEventArgs e)
    {
        //do something with your data
        Console.WriteLine(e.Data);
    }

    //Handle the error
    private static void OnErrorDataReceived(object sender, DataReceivedEventArgs e)
    {
        Console.WriteLine(e.Data);
    }

    // Handle Exited event and display process information.
    //private static void OnExited(object sender, System.EventArgs e)
    //{
    //    var process = sender as Process;
    //    if (process != null)
    //    {
    //        Console.WriteLine("ExitCode: " + process.ExitCode);
    //    }
    //    else
    //    {
    //        Console.WriteLine("Process exited");
    //    }
    //}
}

Код, который необходимо скомпилировать внутри VS2007, используя командную строку csc.exe, сгенерированный исполняемый файл не будет правильно отображать вывод консоли или даже выйдет из строя с ошибкой CLR20r3. Закомментируйте процесс события OnExited, консольный вывод bat в exe будет больше похож на исходный вывод консоли bat.

2

Источник

user2324547 09 июл '20 в 23:20

Просто для удовольствия, вот мое законченное решение для получения вывода PYTHON - при нажатии кнопки - с отчетом об ошибках. Просто добавьте кнопку "butPython" и метку "llHello"...

    private void butPython(object sender, EventArgs e)
    {
        llHello.Text = "Calling Python...";
        this.Refresh();
        Tuple<String,String> python = GoPython(@"C:\Users\BLAH\Desktop\Code\Python\BLAH.py");
        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); 
            }
    }

0

Источник

user1451197 01 мар '18 в 11:37

Другие вопросы по тегам c# command-line

user28309 15 окт '08 в 20:36 2008-10-15 20:36 · Accepted Answer · 2008-10-15 20:36

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