Hoe om DLR gebruik met MEF in Net 4,0?

Question

Daar was beloftes van die MEF span wat MEF DLR plugins sal ondersteun in die Net 4,0. Het dit gebeur reeds en ek kan [Import] 'n paar IronPython voorwerpe?

Indien wel, enige skakels na die onderwerp sou nuttig wees.

Answer 1

Die standaard programmering model ondersteun nie die DLR, maar ander programmeringsmodelle geskryf kan word dat dit sal ondersteun, en dit kan gebruik word saam met die verstek ontwikkeling model.

• blog post op die MEF Primitieven (wat gebruik word om programmeringsmodelle te skep).
• blog post met 'n paar idees oor hoe 'n Ruby programmeringstaal model kan werk
• Hoe om skryf 'n persoonlike opdrag vir Intellipad (Intellipad gebruik MEF en 'n luislang ontwikkeling model)

Answer 2

Ek weet dit is oud, maar jy kan kyk na http://github.com/JogoShugh/IronPythonMef of kyk vir die NuGet pakket.

Ek trek 'n paar kode uit 'n projek genaamd ILoveLucene deur Bruno Lopes, en omskep dit in hierdie onafhanklike repo en pakket. Dit is maar net begin, maar het 'n paar voorbeelde ingesluit, en eenheid toetse.

Hier is 'n voorbeeld:

using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.ComponentModel.Composition.Primitives;
using System.Reflection;
using IronPython.Hosting;
using IronPythonMef;

public interface IMessenger
{
    string GetMessage();
}

public interface IConfig
{
    string Intro { get; }
}

/// <summary>
/// Gets exported from IronPython into the CLR Demo instance.
/// </summary>
public static class PythonScript
{
    public static readonly string Code =
@"
@export(IMessenger)
class PythonMessenger(IMessenger):
    def GetMessage(self):
        return self.config.Intro + ' from IronPython'

    @import_one(IConfig)
    def import_config(self, config):
        self.config = config
";
}

/// <summary>
/// Also gets exported into the Demo instance.
/// </summary>
[Export(typeof(IMessenger))]
public class ClrMessenger : IMessenger
{
    [Import(typeof(IConfig))]
    public IConfig Config { get; set; }

    public string GetMessage()
    {
        return Config.Intro + " from C#!";
    }
}

/// <summary>
/// This will get imported into both the IronPython class and ClrMessenger.
/// </summary>
[Export(typeof(IConfig))]
public class Config : IConfig
{
    public string Intro
    {
        get { return "Hello"; }
    }
}

public class Demo
{
    [ImportMany(typeof(IMessenger))]
    public IEnumerable<IMessenger> Messengers { get; set; }

    public Demo()
    {
        // Create IronPython
        var engine = Python.CreateEngine();
        var script = engine.CreateScriptSourceFromString(PythonScript.Code);

        // Configure the engine with types
        var typesYouWantPythonToHaveAccessTo = new[] { typeof(IMessenger), typeof(IConfig) };
        var typeExtractor = new ExtractTypesFromScript(engine);
        var exports = typeExtractor.GetPartsFromScript(script,
            typesYouWantPythonToHaveAccessTo);

        // Compose with MEF
        var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
        var container = new CompositionContainer(catalog);
        var batch = new CompositionBatch(exports, new ComposablePart[] { });
        container.Compose(batch);
        container.SatisfyImportsOnce(this);
    }

    public static void Main(string[] args)
    {
        var demo = new Demo();

        foreach (var messenger in demo.Messengers)
        {
            Console.WriteLine(messenger.GetMessage());
        }

        Console.Read();
    }
}

Die produksie is eenvoudig:

Hello from IronPython!
Hello from C#!