C # 'dan bir Python komut dosyasını nasıl çalıştırırım?

Bu tür bir soru daha önce çeşitli derecelerde sorulmuştu, ancak kısa bir şekilde yanıtlanmadığını hissediyorum ve bu yüzden tekrar soruyorum.

Python'da bir komut dosyası çalıştırmak istiyorum. Diyelim ki bu:

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

Dosya konumu alır, okur ve ardından içeriğini yazdırır. O kadar karmaşık değil.

Tamam, peki bunu C # 'da nasıl çalıştırırım?

Şu an sahip olduğum şey bu:

    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);
            }
        }
    }

Ben geçtikten sonra code.pyolarak yerini cmdve filenamekonum olarak argsçalışmıyor. Ben geçmelidir söylendi python.exeolarak cmdve daha sonra, code.py filenamesıra args.

Bir süredir arıyordum ve sadece IronPython veya benzeri kullanmayı öneren kişileri bulabiliyorum. Ancak C # 'dan bir Python betiğini çağırmanın bir yolu olmalı.

Bazı açıklamalar:

C # üzerinden çalıştırmam gerekiyor, çıktıyı yakalamam gerekiyor ve IronPython veya başka bir şey kullanamıyorum. Sahip olduğunuz hack ne olursa olsun iyi olacak.

Not: Çalıştırdığım gerçek Python kodu bundan çok daha karmaşık ve C # 'da ihtiyacım olan çıktıyı döndürüyor ve C # kodu sürekli olarak Python kodunu çağırıyor olacak.

Bunun benim kodum olduğunu farz et:

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

Çalışmamasının nedeni, sahip olmanızdır UseShellExecute = false.

Kabuğu kullanmazsanız, python çalıştırılabilirinin tam yolunu olarak sağlamanız ve hem komut dosyanızı hem de okumak istediğiniz dosyayı sağlayacak dizeyi FileNameoluşturmanız gerekir Arguments.

Ayrıca, RedirectStandardOutputsürece yapamayacağınızı unutmayın UseShellExecute = false.

Argüman dizesinin python için nasıl biçimlendirilmesi gerektiğinden tam olarak emin değilim, ancak bunun gibi bir şeye ihtiyacınız olacak:

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);
         }
     }
}

IronPython'u kullanmak istiyorsanız, komut dosyalarını doğrudan C # ile çalıştırabilirsiniz:

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

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

IronPython'u buradan edinin.

C'den Python betiğini yürütün

Bir C # projesi oluşturun ve aşağıdaki kodu yazın.

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

"Python C # Testi" yazdır

C # konsolunda 'Python C # Testi'ni göreceksiniz .

Ben de aynı problemle karşılaştım ve Üstat Ahlak'ın cevabı benim için yapmadı. Önceki cevaba dayanan aşağıdakiler işe yaradı:

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);
     }
 }
}

Örnek olarak, test.py'yi cmd satır bağımsız değişkeni 100 ile çalıştırmak istiyorsanız , cmd olacaktır @C:/Python26/python.exeve args olacaktır C://Python26//test.py 100. .Py dosyasının yolunun @ sembolüne sahip olmadığına dikkat edin.

Sadece buna dikkatinizi çekmek için:

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

Harika çalışıyor.

WorkingDirectory'yi ayarlayın veya bağımsız değişkendeki python betiğinin tam yolunu belirtin

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);
    }
}

Aslında Csharp (VS) ve IronPython ile Python arasında entegrasyon yapmak oldukça kolaydır. O kadar karmaşık değil ... Chris Dunaway'in cevap bölümünde söylediği gibi, bu inegrasyonu kendi projem için inşa etmeye başladım. N oldukça basit. Sadece şu adımları izleyin N sonuçlarınızı alacaksınız.

1. adım: VS'yi açın ve yeni boş ConsoleApp projesi oluşturun.

adım 2: Araçlar -> NuGet Paket Yöneticisi -> Paket Yöneticisi Konsolu'na gidin.

Adım 3: Bundan sonra tarayıcınızda bu bağlantıyı açın ve NuGet Komutunu kopyalayın. Bağlantı: https://www.nuget.org/packages/IronPython/2.7.9

adım 4: Yukarıdaki bağlantıyı açtıktan sonra PM> Install-Package IronPython -Version 2.7.9 komutunu kopyalayın ve VS'deki NuGet Konsoluna yapıştırın. Destekleyici paketleri kuracaktır.

Adım 5: Bu, Python.exe dizinimde depolanan bir .py dosyasını çalıştırmak için kullandığım kodum.

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
}
} 

6. adım: kodu kaydedin ve yürütün

Sorun yaşıyorum stdin/stout- yük boyutu birkaç kilobaytı aştığında askıda kalıyor. Python işlevlerini sadece bazı kısa argümanlarla değil, büyük olabilecek özel bir yük ile çağırmam gerekiyor.

Bir süre önce, Redis aracılığıyla farklı makinelerde görev dağıtılmasına izin veren sanal bir aktör kitaplığı yazmıştım. Python kodunu çağırmak için, Python'dan gelen mesajları dinlemek, işlemek ve sonuçları .NET'e geri döndürmek için işlevsellik ekledim. İşte nasıl çalıştığına dair kısa bir açıklama .

Tek bir makinede de çalışır, ancak bir Redis örneği gerektirir. Redis, bazı güvenilirlik garantileri ekler - işlenen bir onaylama tamamlanana kadar yük depolanır. Çalışılan bir ölürse, yük bir iş kuyruğuna döndürülür ve ardından başka bir çalışan tarafından yeniden işlenir.