Utilisation du MEF pour importer des composants exportés par IronPython ou d'autres langages DLR ?

Question

Est-il possible de déclarer des classes IronPython comme "Export" et ainsi les ajouter à un catalogue MEF qu'une application hôte C# peut importer ? une application C# hôte peut importer ?

Je ne peux pas vraiment trouver d'exemples concrets de cela, juste des spéculations.

Voici comment j'ai chargé manuellement une classe Python qui implémente une interface .NET :

https://github.com/versionone/VersionOne.SDK.Experimental

J'aimerais pouvoir mettre des attributs sur les classes python de la même manière que vous le faites en C#. (Ou quelque chose d'équivalent)

Quelqu'un a-t-il essayé ?

Merci, Josh

Answer 1

Pour ceux qui sont intéressés, j'ai trouvé un projet sur GitHub qui avait fait cela, mais qui était un peu couplé dans le projet. Avec l'accord de l'auteur, j'ai créé un nouveau repo, IronPythonMef et un Paquet NuGet pour cela.

Il y a une discussion supplémentaire dans ce fil sur GitHub.

Voici un exemple de son fonctionnement :

Tout d'abord, une interface déclarée en C# :

namespace IronPythonMef.Tests.Example.Operations
{
    public interface IOperation
    {
        object Execute(params object[] args);
        string Name { get; }
        string Usage { get; }
    }
}

Une implémentation qui exporte cette interface en C# :

[Export(typeof(IOperation))]
public class Power : IOperation
{
    public object Execute(params object[] args)
    {
        if (args.Length < 2)
        {
            throw new ArgumentException(Usage, "args");
        }

        var x = Convert.ToDouble(args[0]);
        var y = Convert.ToDouble(args[1]);

        return Math.Pow(x, y);
    }

    public string Name
    {
        get { return "pow"; }
    }

    public string Usage
    {
        get { return "pow n, y -- calculates n to the y power"; }
    }
}

Et, une implémentation de IOperation dans IronPython :

@export(IOperation)
class Fibonacci(IOperation):
    def Execute(self, n):
        n = int(n)
        if n == 0:
            return 0
        elif n == 1:
            return 1
        else:
            return self.Execute(n-1) + self.Execute(n-2)

    @property
    def Name(self):
        return "fib"

    @property
    def Usage(self):
        return "fib n -- calculates the nth Fibonacci number"

Et voici un cas de test d'une classe qui importe ces opérations à la fois de C# et d'IronPython et les exécute :

[TestFixture]
public class MathWizardTests
{
    [Test]
    public void runs_script_with_operations_from_both_csharp_and_python()
    {
        var mathWiz = new MathWizard();

        new CompositionHelper().ComposeWithTypesExportedFromPythonAndCSharp(
            mathWiz,
            "Operations.Python.py",
            typeof(IOperation));

        const string mathScript =
@"fib 6
fac 6
abs -99
pow 2 4
";
        var results = mathWiz.ExecuteScript(mathScript).ToList();

        Assert.AreEqual(8, results[0]);
        Assert.AreEqual(720, results[1]);
        Assert.AreEqual(99f, results[2]);
        Assert.AreEqual(16m, results[3]);
    }
}