Exécutez des scripts Python de manière synchrone à partir de C #

introduction

Jusqu'à présent, j'ai écrit des histoires similaires sur l'intégration entre C # et Python.

Dans "Exécuter le script Python à partir de l'application C # GUI", vous pouvez exécuter le script Python et vérifier la progression jusqu'à ce que le processus soit terminé.

Dans "Exécuter le code Python à partir de l'interface graphique C #", j'ai essayé de rendre possible la saisie du code Python depuis l'écran au lieu du script Python.

Et dans "Exécuter et gérer les processus en arrière-plan à partir de l'interface graphique C #", après avoir exécuté Python, effectuez un autre travail sans attendre la fin. En même temps, j'ai cherché comment vérifier l'état d'exécution lorsque j'étais intéressé.

C'est donc la dernière histoire de cette série.

** En premier lieu, je souhaite créer une méthode qui exécute un script Python et reçoit le résultat du traitement d'une interface graphique, mais que faites-vous? ** **

En bref, c'est un appel qui démarre un script Python sans passer par l'interface graphique, y attend (se synchronise) sans passer au processus suivant jusqu'à ce que l'exécution soit terminée, puis obtient le résultat.

La source

Oui, non.

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

        }

        ///Comportement lorsque le bouton d'exécution est cliqué
        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;

            //Exécution du processus
            p.Start();

            //Écrire dans l'entrée standard
            using (StreamWriter sw = p.StandardInput)
            {
                sw.Write(InputString);
            }

            //Commencer à lire la sortie et l'erreur de manière asynchrone
            p.BeginOutputReadLine();
            p.BeginErrorReadLine();

            //Attends la fin
            p.WaitForExit();
            this.ExitCode = p.ExitCode;
            this.StandardOutput = standardOutputStringBuilder.ToString();
        }

        /// <summary>
        ///Traitement lorsque des données de sortie standard sont reçues
        /// </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>
        ///Que faire lorsqu'une erreur standard est reçue
        /// </summary>
        void p_ErrorDataReceived(object sender,
            System.Diagnostics.DataReceivedEventArgs e)
        {
            //Ecrire le traitement nécessaire
        }
    }
}

Commentaire de la source

Rien de nouveau, lancez simplement `` WaitForExit () '' lorsque vous démarrez le processus. Vous ne pourrez pas continuer tant que le processus ne sera pas terminé. En conséquence, un appel synchrone peut être réalisé. Une fois l'exécution terminée, le code de fin et les données de sortie standard peuvent être obtenus à partir des propriétés.

Comment utiliser

Voici un exemple de transmission de données à l'entrée standard d'un script et de réception de la sortie de résultat vers la sortie standard.

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"; //Données fournies à l'entrée standard
pe.Execute(); //Courir
Console.WriteLine(pe.StandardOutput); //Résultat de sortie standard de sortie

2020/2/24 révisé

Corrigé comme suit car il y avait un bug fatal qui a démarré le processus deux fois. Nous nous excusons pour le dérangement.

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

en conclusion

En bref, c'est une histoire sur la création d'un composant qui prend en charge toutes les méthodes d'appel qui sont sorties jusqu'à présent.

Plus tard, le titre est un script Python, mais il en est de même s'il peut être exécuté à partir de la ligne de commande.