(1) Mit dem folgenden Code erhalte ich genau 2 Artikel in meinen Containern mit ein und demselben exportierten Plugin und frage mich, warum:

(2) Zusätzliche Frage, die ich wirklich nicht implementieren kann: Wie kann ich das Framework erweitern, um verschiedene Plugin-Typen zu behandeln (z. B. mehrere Importe verschiedener Typen oder ein Import, der alle Plugins in einer dynamischen IEnumerable oder so speichert). Ich möchte in meiner statischen Wrapper-Klasse eine generische Methode bereitstellen, die das erkannte Plugin als Funktion des Typs und der übereinstimmenden Metadaten zurückgibt.

Das exportierte Plugin (das sich in einer separaten DLL befindet und auf dessen Position verwiesen wird, wenn dieDirectoryCatalog ist gebaut.

[Export(typeof(IPlugin))] //<---- If this line is commented out then only one item is imported (why?)
[PluginAttribute(typeof(StrategyPlugin_Test1), "StrategyPlugin", "Plugin1")]
public class StrategyPlugin_Test1 : IPlugin
{
    public void DoSomething()
    {
        Console.WriteLine("I do something");
    }
}

Der folgende Code definiert die stark typisierten Metadaten und Importe sowie eine statische Klasse, die die MEF-Funktionen ausführt und die erkannten Plugins enthalten soll:

[MetadataAttribute]
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class PluginAttribute : ExportAttribute
{
    public Type PluginType { get; set; }
    public string PluginGroupName { get; set; }
    public string PluginName { get; set; }

    public PluginAttribute(Type pluginType, string pluginGroupName, string pluginName) : base(typeof(IPlugin))
    {
        PluginType = pluginType;
        PluginGroupName = pluginGroupName;
        PluginName = pluginName;
    }
}

public interface IPluginAttribute
{
    Type PluginType { get; }
    string PluginGroupName { get; }
    string PluginName { get; }
}

public interface IPlugin
{
    void DoSomething();
}

public class PluginDefinition
{
    [ImportMany(typeof(IPlugin))]
    public IEnumerable<Lazy<IPlugin, IPluginAttribute>> Plugins { get; set; }

    public PluginDefinition()
    {

    }
}

Hier die statische Klasse, die einige der wichtigsten MEF-Elemente umschließt:

public static class PluginManager
{
    private static PluginDefinition PluginDefinitions { get; set; }

    static PluginManager()
    {}

    public static void Configure(PluginDefinition pluginDefinitions, IEnumerable<string> pluginDirectories)
    {
        AggregateCatalog aggregateCatalog = new AggregateCatalog(new DirectoryCatalog(pluginDirectories.FirstOrDefault()));
        CompositionContainer container = new CompositionContainer(aggregateCatalog);
        container.ComposeParts(pluginDefinitions);

        //store plugin definition
        PluginDefinitions = pluginDefinitions;


    }

    public static T GetPlugin<T>(string pluginName, string pluginGroupName) where T : class
    {
        //how to implement this given type of T could be any of the plugin types ...
        //...provided for in an extended PluginDefinition class?

        return null;
    }

}