Comment exécuter un script Python à partir de C #?

Ce genre de question a déjà été posé à des degrés divers, mais j'estime qu'il n'y a pas eu de réponse concise et je la pose donc à nouveau.

Je souhaite exécuter un script en Python. Disons que c'est ceci:

if __name__ == '__main__':
    with open(sys.argv[1], 'r') as f:
        s = f.read()
    print s

Qui obtient un emplacement de fichier, le lit, puis imprime son contenu. Pas si compliqué.

D'accord, alors comment puis-je l'exécuter en C #?

Voici ce que j'ai maintenant:

    private void run_cmd(string cmd, string args)
    {
        ProcessStartInfo start = new ProcessStartInfo();
        start.FileName = cmd;
        start.Arguments = args;
        start.UseShellExecute = false;
        start.RedirectStandardOutput = true;
        using (Process process = Process.Start(start))
        {
            using (StreamReader reader = process.StandardOutput)
            {
                string result = reader.ReadToEnd();
                Console.Write(result);
            }
        }
    }

Quand je passe l' code.pyemplacement au fur cmdet à mesure et l' filenameemplacement car argscela ne fonctionne pas. On m'a dit que je devrais passer python.exepour le cmd, puis code.py filenamecomme le args.

Je cherche depuis un moment maintenant et je ne peux trouver que des personnes suggérant d'utiliser IronPython ou autre. Mais il doit y avoir un moyen d'appeler un script Python à partir de C #.

Quelques précisions:

Je dois l'exécuter à partir de C #, je dois capturer la sortie et je ne peux pas utiliser IronPython ou quoi que ce soit d'autre. Quel que soit le hack que vous avez, ce sera bien.

PS: Le code Python que j'exécute est beaucoup plus complexe que cela, et il renvoie la sortie dont j'ai besoin en C #, et le code C # appellera constamment le code Python.

Prétendez que c'est mon code:

    private void get_vals()
    {
        for (int i = 0; i < 100; i++)
        {
            run_cmd("code.py", i);
        }
    }

La raison pour laquelle cela ne fonctionne pas est que vous avez UseShellExecute = false.

Si vous n'utilisez pas le shell, vous devrez fournir le chemin complet de l'exécutable python en tant que FileName, et créer la Argumentschaîne pour fournir à la fois votre script et le fichier que vous souhaitez lire.

Notez également que vous ne pouvez pas à RedirectStandardOutputmoins UseShellExecute = false.

Je ne sais pas trop comment la chaîne d'argument doit être formatée pour python, mais vous aurez besoin de quelque chose comme ceci:

private void run_cmd(string cmd, string args)
{
     ProcessStartInfo start = new ProcessStartInfo();
     start.FileName = "my/full/path/to/python.exe";
     start.Arguments = string.Format("{0} {1}", cmd, args);
     start.UseShellExecute = false;
     start.RedirectStandardOutput = true;
     using(Process process = Process.Start(start))
     {
         using(StreamReader reader = process.StandardOutput)
         {
             string result = reader.ReadToEnd();
             Console.Write(result);
         }
     }
}

Si vous souhaitez utiliser IronPython, vous pouvez exécuter des scripts directement en C #:

using IronPython.Hosting;
using Microsoft.Scripting.Hosting;

private static void doPython()
{
    ScriptEngine engine = Python.CreateEngine();
    engine.ExecuteFile(@"test.py");
}

Obtenez IronPython ici.

Exécuter le script Python à partir de C

Créez un projet C # et écrivez le code suivant.

using System;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            run_cmd();
        }

        private void run_cmd()
        {

            string fileName = @"C:\sample_script.py";

            Process p = new Process();
            p.StartInfo = new ProcessStartInfo(@"C:\Python27\python.exe", fileName)
            {
                RedirectStandardOutput = true,
                UseShellExecute = false,
                CreateNoWindow = true
            };
            p.Start();

            string output = p.StandardOutput.ReadToEnd();
            p.WaitForExit();

            Console.WriteLine(output);

            Console.ReadLine();

        }
    }
}

Python sample_script

print "Test Python C #"

Vous verrez le 'Python C # Test' dans la console de C #.

J'ai rencontré le même problème et la réponse de Maître Moralité ne l'a pas fait pour moi. Ce qui suit, basé sur la réponse précédente, a fonctionné:

private void run_cmd(string cmd, string args)
{
 ProcessStartInfo start = new ProcessStartInfo();
 start.FileName = cmd;//cmd is full path to python.exe
 start.Arguments = args;//args is path to .py file and any cmd line args
 start.UseShellExecute = false;
 start.RedirectStandardOutput = true;
 using(Process process = Process.Start(start))
 {
     using(StreamReader reader = process.StandardOutput)
     {
         string result = reader.ReadToEnd();
         Console.Write(result);
     }
 }
}

Par exemple, cmd serait @C:/Python26/python.exeet args serait C://Python26//test.py 100si vous vouliez exécuter test.py avec l'argument de ligne cmd 100. Notez que le chemin du fichier .py n'a pas le symbole @.

Juste aussi pour attirer votre attention sur ceci:

https://code.msdn.microsoft.com/windowsdesktop/C-and-Python-interprocess-171378ee

Cela fonctionne très bien.

Définissez WorkingDirectory ou spécifiez le chemin complet du script python dans l'argument

ProcessStartInfo start = new ProcessStartInfo();
start.FileName = "C:\\Python27\\python.exe";
//start.WorkingDirectory = @"D:\script";
start.Arguments = string.Format("D:\\script\\test.py -a {0} -b {1} ", "some param", "some other param");
start.UseShellExecute = false;
start.RedirectStandardOutput = true;
using (Process process = Process.Start(start))
{
    using (StreamReader reader = process.StandardOutput)
    {
        string result = reader.ReadToEnd();
        Console.Write(result);
    }
}

En fait, il est assez facile de faire une intégration entre Csharp (VS) et Python avec IronPython. Ce n'est pas si complexe ... Comme Chris Dunaway l'a déjà dit dans la section réponse, j'ai commencé à construire cette intégration pour mon propre projet. N c'est assez simple. Suivez simplement ces étapes N vous obtiendrez vos résultats.

Étape 1: Ouvrez VS et créez un nouveau projet ConsoleApp vide.

Étape 2: Accédez aux outils -> NuGet Package Manager -> Package Manager Console.

Étape 3: Après cela, ouvrez ce lien dans votre navigateur et copiez la commande NuGet. Lien: https://www.nuget.org/packages/IronPython/2.7.9

Étape 4: Après avoir ouvert le lien ci-dessus, copiez la commande PM> Install-Package IronPython -Version 2.7.9 et collez-la dans NuGet Console dans VS. Il installera les packages de support.

étape 5: c'est mon code que j'ai utilisé pour exécuter un fichier .py stocké dans mon répertoire Python.exe.

using IronPython.Hosting;//for DLHE
using Microsoft.Scripting.Hosting;//provides scripting abilities comparable to batch files
using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Sockets;
class Hi
{
private static void Main(string []args)
{
Process process = new Process(); //to make a process call
ScriptEngine engine = Python.CreateEngine(); //For Engine to initiate the script
engine.ExecuteFile(@"C:\Users\daulmalik\AppData\Local\Programs\Python\Python37\p1.py");//Path of my .py file that I would like to see running in console after running my .cs file from VS.//process.StandardInput.Flush();
process.StandardInput.Close();//to close
process.WaitForExit();//to hold the process i.e. cmd screen as output
}
} 

étape 6: enregistrer et exécuter le code

J'ai des problèmes avec stdin/stout- lorsque la taille de la charge utile dépasse plusieurs kilo-octets, elle se bloque. J'ai besoin d'appeler des fonctions Python non seulement avec de courts arguments, mais avec une charge utile personnalisée qui pourrait être importante.

Il y a quelque temps, j'ai écrit une bibliothèque d'acteurs virtuels qui permet de distribuer des tâches sur différentes machines via Redis. Pour appeler du code Python, j'ai ajouté une fonctionnalité permettant d'écouter les messages de Python, de les traiter et de renvoyer les résultats à .NET. Voici une brève description de son fonctionnement .

Il fonctionne également sur une seule machine, mais nécessite une instance Redis. Redis ajoute quelques garanties de fiabilité - la charge utile est stockée jusqu'à ce qu'un travail confirme l'achèvement. Si un ouvré meurt, la charge utile est renvoyée dans une file d'attente de travaux, puis est retraité par un autre travailleur.