Exécuter du code Python à partir de l'interface graphique C #
introduction
C'est une extension de Exécuter le script Python depuis l'application GUI C #, et il est dit que le code source python entré directement depuis l'interface graphique peut être exécuté.
Ce que j'ai fait
L'écran est le suivant. L'écran affiche le résultat de l'exécution du calcul par numpy.
Si la syntaxe est différente, l'erreur suivante s'affiche.
La source
Je viens de sauvegarder le code Python entré par l'utilisateur en tant que script python dans un dossier temporaire et de laisser pytnon.exe l'exécuter, rien de nouveau techniquement.
Cependant, c'est amusant de pouvoir entrer et exécuter librement du code Python sur place.
En tant qu'exemple d'application qui m'est venu à l'esprit, je pense qu'il peut être utilisé lors de la distribution de code Python que vous ne voulez absolument pas voir.
Enfin, la source est décrite. Veuillez vous référer à Exécuter le script Python à partir de l'application GUI C # pour l'explication.
using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading;
using System.Windows.Forms;
namespace PythonExecutor
{
public partial class Form1 : Form
{
private Process currentProcess;
private StringBuilder outStringBuilder = new StringBuilder();
private int readCount = 0;
private Boolean isCanceled = false;
private String pythonFileName = "temporaryPythonFile.py";
public Form1()
{
InitializeComponent();
}
/// <summary>
///Ajouter une chaîne à la zone de texte
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void AppendText(String data, Boolean console)
{
textBox1.AppendText(data);
if (console)
{
textBox1.AppendText("\r\n");
Console.WriteLine(data);
}
}
/// <summary>
///Comportement lorsque le bouton d'exécution est cliqué
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button1_Click(object sender, EventArgs e)
{
if (Directory.Exists(this.textBox3.Text.Trim()))
{
//Écrire dans un fichier python dans le dossier de travail
String path = this.textBox3.Text.Trim() + System.IO.Path.DirectorySeparatorChar + this.pythonFileName;
using (StreamWriter writer = new StreamWriter(path))
{
StringReader strReader = new StringReader(this.textBox4.Text.Trim());
while (true)
{
String aLine = strReader.ReadLine();
if (aLine != null)
{
writer.WriteLine(aLine);
}
else
{
break;
}
}
writer.Close();
}
//Prétraitement
button1.Enabled = false;
button2.Enabled = true;
isCanceled = false;
readCount = 0;
outStringBuilder.Clear();
this.Invoke((MethodInvoker)(() => this.textBox1.Clear()));
//Courir
RunCommandLineAsync(path);
}
else
{
this.Invoke((MethodInvoker)(() => MessageBox.Show("Le dossier de travail n'est pas valide")));
}
}
/// <summary>
///Corps du processus d'exécution de la commande
/// </summary>
public void RunCommandLineAsync(String pythonScriptPath)
{
ProcessStartInfo psInfo = new ProcessStartInfo();
psInfo.FileName = this.textBox2.Text.Trim();
psInfo.WorkingDirectory = this.textBox3.Text.Trim();
// psInfo.Arguments = this.textBox4.Text.Trim();
psInfo.Arguments = pythonScriptPath;
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.EnableRaisingEvents = true;
p.Exited += onExited;
p.OutputDataReceived += p_OutputDataReceived;
p.ErrorDataReceived += p_ErrorDataReceived;
p.Start();
//Commencer à lire la sortie et l'erreur de manière asynchrone
p.BeginOutputReadLine();
p.BeginErrorReadLine();
currentProcess = p;
}
void onExited(object sender, EventArgs e)
{
int exitCode;
if (currentProcess != null)
{
currentProcess.WaitForExit();
//Expirer des données qui restent sans être expirées
this.Invoke((MethodInvoker)(() => AppendText(outStringBuilder.ToString(), false)));
outStringBuilder.Clear();
exitCode = currentProcess.ExitCode;
currentProcess.CancelOutputRead();
currentProcess.CancelErrorRead();
currentProcess.Close();
currentProcess.Dispose();
currentProcess = null;
//Supprimer le fichier python
String pythonFilepath = this.textBox3.Text.Trim() + System.IO.Path.DirectorySeparatorChar + this.pythonFileName;
if (File.Exists(pythonFilepath)) ;
{
File.Delete(pythonFilepath);
}
this.Invoke((MethodInvoker)(() => this.button1.Enabled = true));
this.Invoke((MethodInvoker)(() => this.button2.Enabled=false));
if (isCanceled)
{
//Message de fin
this.Invoke((MethodInvoker)(() => MessageBox.Show("Traitement annulé")));
}
else
{
if (exitCode == 0)
{
//Message de fin
this.Invoke((MethodInvoker)(() => MessageBox.Show("Le traitement est terminé")));
}
else
{
//Message de fin
this.Invoke((MethodInvoker)(() => MessageBox.Show("Une erreur est survenue")));
}
}
}
}
/// <summary>
///Traitement lorsque des données de sortie standard sont reçues
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void p_OutputDataReceived(object sender,
System.Diagnostics.DataReceivedEventArgs e)
{
processMessage(sender, e);
}
/// <summary>
///Que faire lorsqu'une erreur standard est reçue
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void p_ErrorDataReceived(object sender,
System.Diagnostics.DataReceivedEventArgs e)
{
processMessage(sender, e);
}
/// <summary>
///Reçoit les données du programme CommandLine et les recrache dans TextBox
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void processMessage(object sender, System.Diagnostics.DataReceivedEventArgs e)
{
if (e != null && e.Data != null && e.Data.Length > 0)
{
outStringBuilder.Append(e.Data + "\r\n");
}
readCount++;
//Expirez à un moment cohérent
if (readCount % 5 == 0)
{
this.Invoke((MethodInvoker)(() => AppendText(outStringBuilder.ToString(), false)));
outStringBuilder.Clear();
//Mettre en veille pour qu'il n'occupe pas le fil
if (readCount % 1000 == 0)
{
Thread.Sleep(100);
}
}
}
/// <summary>
///Comportement lorsque le bouton d'annulation est cliqué
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button2_Click(object sender, EventArgs e)
{
if (currentProcess != null)
{
try
{
currentProcess.Kill();
isCanceled = true;
}
catch (Exception e2)
{
Console.WriteLine(e2);
}
}
}
private void button3_Click(object sender, EventArgs e)
{
//Effacer la partie de code Python
this.textBox4.Clear();
//Effacer la zone de sortie standard
this.textBox1.Clear();
}
private void textBox1_TextChanged(object sender, EventArgs e)
{
}
}
}
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;
Recommended Posts