像简单的 Funq 容器一样用 C# 组合 MEF 部件

Question

在 Funq 以及可能大多数其他 IoC 容器中，我可以简单地执行此操作来配置类型：

container.Register<ISomeThing>(c => new SomeThing());

How Could I fast Extend MEF （或使用现有的 MEF 功能）在不使用属性的情况下执行相同的操作。

我认为我可以这样做：

var container = new CompositionContainer();
var batch = new CompositionBatch();
batch.AddExport<ISomeThing>(() => new SomeThing());
batch.AddExportedValue(batch);
container.Compose(batch);

使用 CompositionBatch 的扩展方法：

public static ComposablePart AddExport<TKey>(this CompositionBatch batch, Func<object> func)
{
    var typeString = typeof(TKey).ToString();
    return batch.AddExport(
        new Export(
            new ExportDefinition(
                typeString, 
                new Dictionary<string, object>() { { "ExportTypeIdentity", typeString } }),
            func));

}

如果我稍后这样做：

var a = container.GetExport<ISomeThing>().Value;
var b = container.GetExport<ISomeThing>().Value;

两个实例都是相同的。我如何强制（配置）它们为不同的实例？

如果这不是可行的方法，我该如何在 MEF 中执行此操作？

Answer 1

我想关键是将委托添加到容器中，例如：

container.AddExportedValue<Func<ISomething>>(() => new Something());

这样您就可以获取委托并执行它：

var factory = container.GetExport<Func<ISomething>>();
ISomething something = factory();

当然，MEF（Silverlight）确实提供了本机 ExportFactory （和 ExportFactory 类型，支持为每次导入调用创建新实例。您可以通过下载 Glen Block 的 .NET 4.0（桌面）库的 ExportFactory 。

Answer 2

如果你不想使用属性，你可以使用这个技巧（基于标记Seemann 的博文）。

首先，创建一个如下所示的通用类：

[PartCreationPolicy(CreationPolicy.NonShared)]
public class MefAdapter<T> where T : new()
{
    private readonly T export;

    public MefAdapter()
    {
        this.export = new T();
    }

    [Export]
    public virtual T Export
    {
        get { return this.export; }
    }
}

现在您可以在容器中注册您想要的任何类，如下所示：

var registeredTypesCatalog = new TypeCatalog(
    typeof(MefAdapter<Foo>),
    typeof(MefAdapter<Bar>), 
    ...);
var container = new CompositionContainer(catalog);

或者，您可以实现从 ExportProvider，它允许您几乎复制 Funq 的工作方式：

var provider = new FunqyExportProvider();
provider.Register<IFoo>(context => new Foo());
var container = new CompositionContainer(provider);

Answer 3

两个实例是相同的。我如何强制（配置）它们为不同的实例？

只需像这样标记 SomeThing 类：

[Export(typeof(ISomeThing)]
[PartCreationPolicy(CreationPolicy.NonShared]
public class SomeThing : ISomeThing
{
   ...
}

然后无论您在何处导入 ISomeThing，您都会获得不同的实例。

或者，您还可以在导入时设置所需的创建策略：

[Export(typeof(IFoo))]
public class Foo : IFoo
{
   [Import(typeof(ISomeThing), 
       RequiredCreationPolicy = CreationPolicy.NonShared)]
   public ISomething SomeThing { private get; set; }

}

Answer 4

在 Glen Block 的 Skydrive 目录中链接到 Matthew Abbott 的回答 我发现了一些看起来简单且轻量级的东西：FuncCatalog。在这里下载：FuncCatalogExtension。

使用该项目中的几个小类，我现在可以执行以下操作：

var funcCatalog = new FuncCatalog();
funcCatalog.AddPart<ISomeThing>(ep => new SomeThing());
var container = new CompositionContainer(funcCatalog);
var batch = new CompositionBatch();
batch.AddExportedObject<ExportProvider>(container);
container.Compose(batch);

var a = container.GetExportedObject<ISomeThing>();
var b = container.GetExportedObject<ISomeThing>();