studio - palabras reservadas en c# y para que sirven

¿Cómo puedo llamar al código Python(de hierro) desde una aplicación de C#?

Question

¿Hay una manera de llamar al código Python, usando IronPython supongo, desde C #? ¿Si es así, cómo?

Answer 1

Para ejecutar una función no se puede llamar como en la Opción 3 de la respuesta de Jeff Mercado (¡es una excelente y muy útil! Pero esta opción no se compila, al menos en .NET 4.5). Puedes usar ScriptScope.GetVariable para obtener la función real y luego puedes llamarla como una función de C #. Úsalo así:

Código C #:

var var1,var2=...
ScriptEngine engine = Python.CreateEngine();
ScriptScope scope = engine.CreateScope();
engine.ExecuteFile(@"C:/test.py", scope);
dynamic testFunction = scope.GetVariable("test_func");
var result = testFunction(var1,var2);

Código Python:

def test_func(var1,var2):
    ...do something...

Me tomó un tiempo resolverlo finalmente, y es bastante simple ... Lástima que no haya buena documentación de IronPython. Espero que esto ayude :)

Answer 2

El proceso es simple, especialmente en una aplicación C # / .NET 4 donde el soporte para lenguajes dinámicos se ha mejorado mediante el uso del tipo dynamic . Pero, en última instancia, todo depende de cómo intente utilizar el código Python (de hierro) en su aplicación. Siempre puede ejecutar ipy.exe como un proceso separado y pasar sus archivos de origen para que puedan ejecutarse. Pero probablemente quiso alojarlos en su aplicación de C #. Eso te deja con muchas opciones.

1. Agregue una referencia a los ensamblados IronPython.dll y Microsoft.Scripting.dll . Por lo general, los encontrará en su directorio raíz de instalación de IronPython.

2. Añadir using IronPython.Hosting; en la parte superior de su fuente y cree una instancia del motor de scripting IronPython usando Python.CreateEngine() .

3. Tiene un par de opciones desde aquí, pero básicamente crearía un ScriptScope o ScriptSource y lo almacenaría como una variable dynamic . Esto le permite ejecutarlo o manipular los ámbitos desde C # si decide hacerlo.

Opción 1:

Usando CreateScope() para crear un ScriptScope vacío para usar directamente en el código C #, pero se puede usar en fuentes de Python. Puede considerarlas como sus variables globales dentro de una instancia del intérprete.

dynamic scope = engine.CreateScope();
scope.Add = new Func<int, int, int>((x, y) => x + y);
Console.WriteLine(scope.Add(2, 3)); // prints 5

Opcion 2:

Usando Execute() para ejecutar cualquier código de IronPython en una cadena. Puede usar la sobrecarga donde puede pasar en un ScriptScope para almacenar o usar las variables definidas en el código.

var theScript = @"def PrintMessage():
    print ''This is a message!''

PrintMessage()
";

// execute the script
engine.Execute(theScript);

// execute and store variables in scope
engine.Execute(@"print Add(2, 3)", scope);
// uses the `Add()` function as defined earlier in the scope

Opción 3:

Usando ExecuteFile() para ejecutar un archivo fuente de IronPython. Puede usar la sobrecarga donde puede pasar en un ScriptScope para almacenar o usar las variables definidas en el código.

// execute the script
engine.ExecuteFile(@"C:/path/to/script.py");

// execute and store variables in scope
engine.ExecuteFile(@"C:/path/to/script.py", scope);
// variables and functions defined in the scrip are added to the scope
scope.SomeFunction();

Opción 4:

Usando GetBuiltinModule() o el método de extensión ImportModule() para crear un ámbito que contenga las variables definidas en dicho módulo. Los módulos importados de esta manera deben establecerse en las rutas de búsqueda.

dynamic builtin = engine.GetBuiltinModule();
// you can store variables if you want
dynamic list = builtin.list;
dynamic itertools = engine.ImportModule("itertools");
var numbers = new[] { 1, 1, 2, 3, 6, 2, 2 };
Console.WriteLine(builtin.str(list(itertools.chain(numbers, "foobar"))));
// prints `[1, 1, 2, 3, 6, 2, 2, ''f'', ''o'', ''o'', ''b'', ''a'', ''r'']`

// to add to the search paths
var searchPaths = engine.GetSearchPaths();
searchPaths.Add(@"C:/path/to/modules");
engine.SetSearchPaths(searchPaths);

// import the module
dynamic myModule = engine.ImportModule("mymodule");

Puedes hacer bastante alojamiento de código Python en tus proyectos .NET. C # ayuda a cerrar esa brecha más fácil de manejar. Combinando todas las opciones mencionadas aquí, puede hacer casi cualquier cosa que desee. Por supuesto, puede hacer más con las clases que se encuentran en el espacio de nombres de IronPython.Hosting , pero esto debería ser más que suficiente para comenzar.