Process.start: làm thế nào để có được đầu ra?

Tôi muốn chạy một chương trình dòng lệnh bên ngoài từ ứng dụng Mono / .NET của tôi. Ví dụ, tôi muốn chạy mencoder . Có thể:

1. Để có được đầu ra shell dòng lệnh, và viết nó vào hộp văn bản của tôi?
2. Để có được giá trị số để hiển thị một thanh tiến trình với thời gian trôi qua?

Khi bạn tạo bộ Processđối tượng của mình StartInfomột cách thích hợp:

var proc = new Process 
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "program.exe",
        Arguments = "command line arguments to your executable",
        UseShellExecute = false,
        RedirectStandardOutput = true,
        CreateNoWindow = true
    }
};

sau đó bắt đầu quá trình và đọc từ nó:

proc.Start();
while (!proc.StandardOutput.EndOfStream)
{
    string line = proc.StandardOutput.ReadLine();
    // do something with line
}

Bạn có thể sử dụng int.Parse()hoặc int.TryParse()để chuyển đổi các chuỗi thành giá trị số. Trước tiên, bạn có thể phải thực hiện một số thao tác chuỗi nếu có các ký tự số không hợp lệ trong chuỗi bạn đọc.

Bạn có thể xử lý đầu ra của mình một cách đồng bộ hoặc không đồng bộ .

1. Ví dụ đồng bộ

static void runCommand()
{
    Process process = new Process();
    process.StartInfo.FileName = "cmd.exe";
    process.StartInfo.Arguments = "/c DIR"; // Note the /c command (*)
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.RedirectStandardOutput = true;
    process.StartInfo.RedirectStandardError = true;
    process.Start();
    //* Read the output (or the error)
    string output = process.StandardOutput.ReadToEnd();
    Console.WriteLine(output);
    string err = process.StandardError.ReadToEnd();
    Console.WriteLine(err);
    process.WaitForExit();
}

Lưu ý rằng tốt hơn là xử lý cả đầu ra và lỗi : chúng phải được xử lý riêng.

(*) Đối với một số lệnh (ở đây StartInfo.Arguments), bạn phải thêm các /c chỉ thị , nếu không đóng băng quá trình trong WaitForExit().

2. Ví dụ không đồng bộ

static void runCommand() 
{
    //* Create your Process
    Process process = new Process();
    process.StartInfo.FileName = "cmd.exe";
    process.StartInfo.Arguments = "/c DIR";
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.RedirectStandardOutput = true;
    process.StartInfo.RedirectStandardError = true;
    //* Set your output and error (asynchronous) handlers
    process.OutputDataReceived += new DataReceivedEventHandler(OutputHandler);
    process.ErrorDataReceived += new DataReceivedEventHandler(OutputHandler);
    //* Start process and handlers
    process.Start();
    process.BeginOutputReadLine();
    process.BeginErrorReadLine();
    process.WaitForExit();
}

static void OutputHandler(object sendingProcess, DataReceivedEventArgs outLine) 
{
    //* Do your stuff with the output (write to console/log/StringBuilder)
    Console.WriteLine(outLine.Data);
}

Nếu bạn không cần thực hiện các thao tác phức tạp với đầu ra, bạn có thể bỏ qua phương thức OutputHandler, chỉ cần thêm các trình xử lý trực tiếp:

//* Set your output and error (asynchronous) handlers
process.OutputDataReceived += (s, e) => Console.WriteLine(e.Data);
process.ErrorDataReceived += (s, e) => Console.WriteLine(e.Data);

Được rồi, đối với bất kỳ ai muốn đọc cả Lỗi và Đầu ra, nhưng bị bế tắc với bất kỳ giải pháp nào, được cung cấp trong các câu trả lời khác (như tôi), đây là một giải pháp mà tôi đã xây dựng sau khi đọc giải thích MSDN cho thuộc StandardOutputtính.

Câu trả lời dựa trên mã của T30:

static void runCommand()
{
    //* Create your Process
    Process process = new Process();
    process.StartInfo.FileName = "cmd.exe";
    process.StartInfo.Arguments = "/c DIR";
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.RedirectStandardOutput = true;
    process.StartInfo.RedirectStandardError = true;
    //* Set ONLY ONE handler here.
    process.ErrorDataReceived += new DataReceivedEventHandler(ErrorOutputHandler);
    //* Start process
    process.Start();
    //* Read one element asynchronously
    process.BeginErrorReadLine();
    //* Read the other one synchronously
    string output = process.StandardOutput.ReadToEnd();
    Console.WriteLine(output);
    process.WaitForExit();
}

static void ErrorOutputHandler(object sendingProcess, DataReceivedEventArgs outLine) 
{
    //* Do your stuff with the output (write to console/log/StringBuilder)
    Console.WriteLine(outLine.Data);
}

Cách .NET chuẩn để thực hiện việc này là đọc từ luồng StandardOutput của Process . Có một ví dụ trong các tài liệu MSDN được liên kết. Tương tự, bạn có thể đọc từ StandardError và viết thư cho StandardInput .

1. Có thể lấy đầu ra của dòng lệnh của một quy trình như được mô tả ở đây: http://www.c-sharpcorner.com/UploadFile/edwinlima/SystemDiagnellectProcess12052005035444AM/SystemDiagnellectProcess.aspx

2. Điều này phụ thuộc vào mencoder. Nếu nó xuất hiện trạng thái này trên dòng lệnh thì có :)

bạn có thể sử dụng bộ nhớ dùng chung cho 2 tiến trình để liên lạc qua, kiểm tra MemoryMappedFile

Bạn sẽ chủ yếu tạo một tệp ánh xạ bộ nhớ mmftrong quy trình cha mẹ bằng cách sử dụng câu lệnh "bằng cách sử dụng" sau đó tạo quy trình thứ hai cho đến khi nó chấm dứt và để nó ghi kết quả vào việc mmfsử dụng BinaryWriter, sau đó đọc kết quả từ mmfquy trình cha mẹ, bạn cũng có thể truyền mmftên bằng cách sử dụng đối số dòng lệnh hoặc mã cứng.

đảm bảo khi sử dụng tệp được ánh xạ trong quy trình cha mà bạn thực hiện quy trình con ghi kết quả vào tệp được ánh xạ trước khi tệp được ánh xạ được phát hành trong quy trình cha

Ví dụ: quá trình cha mẹ

    private static void Main(string[] args)
    {
        using (MemoryMappedFile mmf = MemoryMappedFile.CreateNew("memfile", 128))
        {
            using (MemoryMappedViewStream stream = mmf.CreateViewStream())
            {
                BinaryWriter writer = new BinaryWriter(stream);
                writer.Write(512);
            }

            Console.WriteLine("Starting the child process");
            // Command line args are separated by a space
            Process p = Process.Start("ChildProcess.exe", "memfile");

            Console.WriteLine("Waiting child to die");

            p.WaitForExit();
            Console.WriteLine("Child died");

            using (MemoryMappedViewStream stream = mmf.CreateViewStream())
            {
                BinaryReader reader = new BinaryReader(stream);
                Console.WriteLine("Result:" + reader.ReadInt32());
            }
        }
        Console.WriteLine("Press any key to continue...");
        Console.ReadKey();
    }

Quá trình con

    private static void Main(string[] args)
    {
        Console.WriteLine("Child process started");
        string mmfName = args[0];

        using (MemoryMappedFile mmf = MemoryMappedFile.OpenExisting(mmfName))
        {
            int readValue;
            using (MemoryMappedViewStream stream = mmf.CreateViewStream())
            {
                BinaryReader reader = new BinaryReader(stream);
                Console.WriteLine("child reading: " + (readValue = reader.ReadInt32()));
            }
            using (MemoryMappedViewStream input = mmf.CreateViewStream())
            {
                BinaryWriter writer = new BinaryWriter(input);
                writer.Write(readValue * 2);
            }
        }

        Console.WriteLine("Press any key to continue...");
        Console.ReadKey();
    }

để sử dụng mẫu này, bạn sẽ cần tạo một giải pháp với 2 dự án bên trong, sau đó bạn lấy kết quả xây dựng của quy trình con từ% childDir% / bin / debug và sao chép nó sang% ParentDirectory% / bin / debug sau đó chạy dự án mẹ

childDir và parentDirectory là tên thư mục của các dự án của bạn trên pc chúc may mắn :)

Cách khởi chạy một quy trình (chẳng hạn như tệp bat, tập lệnh perl, chương trình giao diện điều khiển) và có đầu ra tiêu chuẩn của nó được hiển thị trên biểu mẫu cửa sổ:

processCaller = new ProcessCaller(this);
//processCaller.FileName = @"..\..\hello.bat";
processCaller.FileName = @"commandline.exe";
processCaller.Arguments = "";
processCaller.StdErrReceived += new DataReceivedHandler(writeStreamInfo);
processCaller.StdOutReceived += new DataReceivedHandler(writeStreamInfo);
processCaller.Completed += new EventHandler(processCompletedOrCanceled);
processCaller.Cancelled += new EventHandler(processCompletedOrCanceled);
// processCaller.Failed += no event handler for this one, yet.

this.richTextBox1.Text = "Started function.  Please stand by.." + Environment.NewLine;

// the following function starts a process and returns immediately,
// thus allowing the form to stay responsive.
processCaller.Start();    

Bạn có thể tìm thấy ProcessCallertrên liên kết này: Khởi chạy một quy trình và hiển thị đầu ra tiêu chuẩn của nó

Bạn có thể đăng nhập quá trình đầu ra bằng mã dưới đây:

ProcessStartInfo pinfo = new ProcessStartInfo(item);
pinfo.CreateNoWindow = false;
pinfo.UseShellExecute = true;
pinfo.RedirectStandardOutput = true;
pinfo.RedirectStandardInput = true;
pinfo.RedirectStandardError = true;
pinfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal;
var p = Process.Start(pinfo);
p.WaitForExit();
Process process = Process.Start(new ProcessStartInfo((item + '>' + item + ".txt"))
{
    UseShellExecute = false,
    RedirectStandardOutput = true
});
process.WaitForExit();
string output = process.StandardOutput.ReadToEnd();
if (process.ExitCode != 0) { 
}

Giải pháp hiệu quả với tôi trong win và linux là theo dõi

// GET api/values
        [HttpGet("cifrado/{xml}")]
        public ActionResult<IEnumerable<string>> Cifrado(String xml)
        {
            String nombreXML = DateTime.Now.ToString("ddMMyyyyhhmmss").ToString();
            String archivo = "/app/files/"+nombreXML + ".XML";
            String comando = " --armor --recipient bibankingprd@bi.com.gt  --encrypt " + archivo;
            try{
                System.IO.File.WriteAllText(archivo, xml);                
                //String comando = "C:\\GnuPG\\bin\\gpg.exe --recipient licorera@local.com --armor --encrypt C:\\Users\\Administrador\\Documents\\pruebas\\nuevo.xml ";
                ProcessStartInfo startInfo = new ProcessStartInfo() {FileName = "/usr/bin/gpg",  Arguments = comando }; 
                Process proc = new Process() { StartInfo = startInfo, };
                proc.StartInfo.RedirectStandardOutput = true;
                proc.StartInfo.RedirectStandardError = true;
                proc.Start();
                proc.WaitForExit();
                Console.WriteLine(proc.StandardOutput.ReadToEnd());
                return new string[] { "Archivo encriptado", archivo + " - "+ comando};
            }catch (Exception exception){
                return new string[] { archivo, "exception: "+exception.ToString() + " - "+ comando };
            }
        }