Wie DLR mit MEF in .Net 4.0 verwenden?

Question

Es gab Versprechungen vom MEF-Team, dass MEF DLR-Plugins im .Net 4.0 unterstützt. Ist es schon passiert und ich kann einige IronPython-Objekte [importieren]?

Wenn ja, wären Links zu diesem Thema hilfreich.

Answer 1

Das Standardprogrammierungsmodell unterstützt das DLR nicht, aber es können andere Programmiermodelle geschrieben werden, die es unterstützen und die zusammen mit dem Standardprogrammierungsmodell verwendet werden können.

• Blog post on the MEF Primitives (die zum Erstellen von Programmiermodellen verwendet werden).
• Blog post with some ideas on how a Ruby programming model could work
• How to write a custom command for Intellipad (IntelliPad verwendet MEF und ein Python-Programmiermodell)

Answer 2

Ich weiß, das alt ist, aber Sie können für die NuGet Paket an http://github.com/JogoShugh/IronPythonMef oder anschaut.

Ich zog Code aus einem Projekt namens ILoveLucene von Bruno Lopes und verwandelte es in dieses unabhängige Repo und Paket. Es beginnt gerade, enthält aber einige Beispiele und Komponententests.

Hier ist ein Beispiel:

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

Der Ausgang ist einfach:

Hello from IronPython! 
Hello from C#!