Führen Sie Python-Skripte synchron von C # aus

Einführung

Bisher habe ich einige ähnliche Geschichten über die Integration zwischen C # und Python geschrieben.

Unter "Python-Skript über C # GUI-Anwendung ausführen" können Sie das Python-Skript ausführen und den Fortschritt überprüfen, bis der Vorgang abgeschlossen ist.

In "Python-Code über C # GUI ausführen" habe ich versucht, die Eingabe von Python-Code über den Bildschirm anstelle des Python-Skripts zu ermöglichen.

Und in "Prozesse im Hintergrund über die C # -GUI ausführen und verwalten" führen Sie nach dem Ausführen von Python eine weitere Arbeit aus, ohne auf das Ende zu warten. Gleichzeitig untersuchte ich, wie ich den Ausführungsstatus überprüfen konnte, wenn ich interessiert war.

Daher ist dies die letzte Geschichte in dieser Reihe.

** Zunächst möchte ich eine Methode erstellen, die ein Python-Skript ausführt und das Verarbeitungsergebnis von einer GUI empfängt. Was tun Sie jedoch? ** ** **

Kurz gesagt, es ist ein Aufruf, der ein Python-Skript startet, ohne die GUI zu durchlaufen, dort wartet (synchronisiert), ohne mit dem nächsten Prozess fortzufahren, bis die Ausführung abgeschlossen ist, und dann das Ergebnis erhält.

Quelle

Ja, nicht.

PythonExecutor.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Text;

namespace ChemShow
{
    public class PythonExecutor
    {
        public String FileName { get; set; }
        public String WorkingDirectory { get; set; }
        public String Arguments { get; set; }
        public String InputString { get; set; }
        public String StandardOutput { get; set; }
        public int ExitCode { get; set; }

        private StringBuilder standardOutputStringBuilder = new StringBuilder();

        public PythonExecutor()
        {

        }

        ///Verhalten beim Klicken auf die Schaltfläche Ausführen
        public  void Execute()
        {
            
            ProcessStartInfo psInfo = new ProcessStartInfo();
            psInfo.FileName = this.FileName;
            psInfo.WorkingDirectory = this.WorkingDirectory;
            psInfo.Arguments = this.Arguments;

            psInfo.CreateNoWindow = true;
            psInfo.UseShellExecute = false;
            psInfo.RedirectStandardInput = true;
            psInfo.RedirectStandardOutput = true;
            psInfo.RedirectStandardError = true;

            // Process p = Process.Start(psInfo);
            Process p = new System.Diagnostics.Process();
            p.StartInfo = psInfo;
            p.OutputDataReceived += p_OutputDataReceived;
            p.ErrorDataReceived += p_ErrorDataReceived;

            //Prozessausführung
            p.Start();

            //Schreiben Sie in die Standardeingabe
            using (StreamWriter sw = p.StandardInput)
            {
                sw.Write(InputString);
            }

            //Starten Sie das asynchrone Lesen von Ausgabe und Fehler
            p.BeginOutputReadLine();
            p.BeginErrorReadLine();

            //Warten Sie bis zum Ende
            p.WaitForExit();
            this.ExitCode = p.ExitCode;
            this.StandardOutput = standardOutputStringBuilder.ToString();
        }

        /// <summary>
        ///Verarbeitung beim Empfang von Standardausgabedaten
        /// </summary>
        void p_OutputDataReceived(object sender,
            System.Diagnostics.DataReceivedEventArgs e)
        {
            //processMessage(sender, e);
            if (e != null && e.Data != null && e.Data.Length > 0)
            {
                standardOutputStringBuilder.Append(e.Data + "\n");
            }
        }

        /// <summary>
        ///Was tun, wenn ein Standardfehler empfangen wird?
        /// </summary>
        void p_ErrorDataReceived(object sender,
            System.Diagnostics.DataReceivedEventArgs e)
        {
            //Schreiben Sie die notwendige Verarbeitung
        }
    }
}

Quellenkommentar

Nichts Neues, führen Sie einfach `WaitForExit ()` aus, wenn Sie den Prozess starten. Dann können Sie erst fortfahren, wenn der Vorgang abgeschlossen ist. Dadurch kann ein synchroner Anruf realisiert werden. Nach Abschluss der Ausführung können der Endcode und die Standardausgabedaten aus den Eigenschaften abgerufen werden.

Wie benutzt man

Das folgende Beispiel zeigt, wie Daten an die Standardeingabe eines Skripts übergeben und die Ergebnisausgabe an die Standardausgabe gesendet werden.

PythonExecutor pe = new PythonExecutor();
pe.FileName=@"c:\python3.6\bin\python.exe";
pe.WorkingDirectory = @"c:\tmp";
pe.Arguments =@"C:\ChemShow\python\hist.py";
pe.InputString = "1,2,3,4,5,6,7,8,9,10"; //Daten zur Standardeingabe
pe.Execute(); //Lauf
Console.WriteLine(pe.StandardOutput); //Standardausgabeergebnis ausgeben

2020/2/24 überarbeitet

Es wurde wie folgt behoben, da ein schwerwiegender Fehler auftrat, der den Prozess zweimal startete. Wir entschuldigen uns für die Unannehmlichkeiten.

// Process p = Process.Start(psInfo); Process p = new System.Diagnostics.Process(); p.StartInfo = psInfo;

abschließend

Kurz gesagt, es geht darum, eine Komponente zu erstellen, die allen bisher veröffentlichten Aufrufmethoden entspricht.

Später ist der Titel ein Python-Skript, aber er ist der gleiche, wenn er über die Befehlszeile ausgeführt werden kann.