MEF-导入字典

Question

Iam当前正在重构应用程序，并希望引入MEF。 Export类（Apple类）已完成，并用Export-keyword标记...在导入站点上，我目前有一个字典，其初始化如下所示：

Dictionary<int, Apple> dict = new Dictionary<int, Apple>();
for(int i=0; i < 10; i++)
    dict.add(i, new Apple());

...

如何使用MEF初始化字典？

Answer 1

因此，我认为您的问题可以归结为：“如何确保容器产生一个对象的多个实例，而不是每次请求都重复使用同一对象。” 嗯，这很容易-您只需指定CreationPolicy.NonShared 。

考虑一下IApple示例实现：

public interface IApple { }

[PartCreationPolicy(CreationPolicy.NonShared)]
[Export(typeof(IApple))]
public class Apple : IApple 
{ 
    private static int appleCounter = 0;
    private int id;

    public Apple() 
    {
        this.id = ++appleCounter;
    }

    public override string ToString()
    {
        return "Apple #" + this.id.ToString();
    }
}

这是您可能使用它的一种方式：

class Program
{
    public static void Main(string[] args)
    {
        var catalog = new ApplicationCatalog();
        var container = new CompositionContainer(catalog);
        IDictionary<int, IApple> dict = new Dictionary<int, IApple>();
        for (int i = 0; i < 10; i++)
        {
            dict.Add(i, container.GetExportedValue<IApple>());
        }

        foreach (var pair in dict)
        {
            Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
        }
    }
}

此处的代码关键行是[PartCreationPolicy(CreationPolicy.NonShared)] 。 如果没有这一点，将只有一个Apple被创造出来。 当然，这并不像您期望的那样有用。 这是生成字典的另一种方法，该方法更加灵活：

public interface IBasket
{
    IDictionary<int, IApple> GetAppleDictionary();
}

[Export(typeof(IBasket))]
public class Basket : IBasket
{
    private IDictionary<int, IApple> dict;

    [ImportingConstructor]
    public Basket([Import] CompositionContainer container)
    {
        this.dict = new Dictionary<int, IApple>();
        for (int i = 0; i < 10; i++)
        {
            this.dict.Add(i, container.GetExportedValue<IApple>());
        }
    }

    public IDictionary<int, IApple> GetAppleDictionary()
    {
        return dict;
    }
}

class Program
{
    [Import(typeof(IBasket))]
    private IBasket basket = null;

    public static void Main(string[] args)
    {
        var program = new Program();
        program.Run();
    }

    private void Run()
    {
        var catalog = new ApplicationCatalog();
        var container = CreateCompositionContainer(catalog);
        container.ComposeParts(this);
        foreach (var pair in this.basket.GetAppleDictionary())
        {
            Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
        }
    }

    private static CompositionContainer CreateCompositionContainer(ComposablePartCatalog catalog)
    {
        var wrappedCatalog = new AggregateCatalog(catalog, new TypeCatalog(typeof (CompositionContainer)));
        var container = new CompositionContainer(wrappedCatalog);
        container.ComposeExportedValue(container);

        return container;
    }
}

这里最棘手的部分是CreateCompositionContainer 。 此方法确保CompositionContainer本身可用于满足其所组成对象的导入。 这样一来， Basket可以直接操纵容器来生成所需的所有苹果。

只是出于演示目的，这是您还可以使用[ImportMany]属性完成类似操作的一种方法（尽管所有这些[Export]确实让我畏缩了）：

public interface IApple { }

[PartCreationPolicy(CreationPolicy.NonShared)]
[Export(typeof(IApple))]
[Export(typeof(IApple))]
/* ..repeat N times.. */
[Export(typeof(IApple))]
public class Apple : IApple 
{ 
    private static int appleCounter = 0;
    private int id;

    public Apple() 
    {
        this.id = ++appleCounter;
    }

    public override string ToString()
    {
        return "Apple #" + this.id.ToString();
    }
}

class Program
{
    [ImportMany(typeof(IApple))]
    private IEnumerable<IApple> apples = null;

    public static void Main(string[] args)
    {
        var program = new Program();
        program.Run();
    }

    void Run()
    {
        var catalog = new AssemblyCatalog(this.GetType().Assembly);
        var container = new CompositionContainer(catalog);
        container.ComposeParts(this);
        apples.Dump();
    }
}