通过 MEF 容器处理组件？

Question

我使用 MEF 将接口映射到实现类作为 DI 的一种方式。例如，我对接口使用 Import 属性，对实现类使用 Export 属性。我的理解是MEF框架将创建实现类实例并将它们保存在MEF的容器中以供使用或自动注入。

我的一些实现类实现了 IDispose 接口。由于实例是由 MEF 创建的，我认为如果 MEF 退出时组件是一次性的，我应该让 MEF 调用组件的 Dispose 方法。例如，在我的应用程序中，我保存了对 MEF 容器的引用。当应用程序终止时，我调用容器的 Dispose 方法。问题是我的组件的 Dispose 从未被调用。

以下是一些有关导入和导出映射的示例代码：

[Import]
private IMyInterface IComponent1 { get; set; }
....

[Export]
private IMyInterface Component {
  get {
     var instance = new MyImplemetation();
     ....
     return instance;
 }
}
....

对于其他映射，还有许多其他导入和导出定义，方法类似。我以这种方式构建映射，以便 MEF 了解关系以及如何创建映射实例的方式。以下是我的应用程序中使用 AssemblyCatalog 加载映射的一些代码：

var catalog = new AggregateCatalog();
catalog.Add (new AssemblyCatalog(Assembly.GetExecutingAssembly());
var batch = new CompositionBatch();
batch.AddPart(catalog);
// MEF container has all the mappings
var container = new CompositionContainer(catalog);
....
// Get instance from container
var instance = container.GetExportedValue<IMyInterface>();
// my instance CTOR has a contructor with several other 
// implementation instances injected by interface
// instance starts to do its job and coordinates others ...
instance.Start();
....
// Finally the job is done.
// Dispose the container explicitly there.
container.Dispose();
// But my components are never disposed
// this results some connections not being closed
// file streams not being closed...

这里实例具有 MEF 通过 CTOR 注入的许多其他组件。这些组件还包含由 MEF 注入的其他组件。问题是，由于某些实例是共享的，因此很难决定何时处置组件。如果我对其中一个调用 Dispose，这将导致其他人无法使用它。正如您在此图中所看到的，实例由 MEF 创建并注入到我的应用程序类中。每个组件不应该了解其他组件，并且应该使用注入的组件来完成工作。

我不确定当应用程序终止或容器被处置时，我应该在哪里/如何指示 MEF 在组件上调用 Dispose？我应该调用组件的 Dispose 吗？我认为这是不对的，因为 MEF 创建它们并根据需要将它们注入客户端。客户在完成工作时不应调用 Dispose。

Answer 1

MEF 确实管理它创建的组件的生命周期。您的示例中的问题似乎是您想要处置的对象实际上并不是由 MEF 创建的。也许您想做这样的事情：

public class ComponentExporter : IDisposable
{
    private IMyInterface _component;

    [Export]
    public IMyInterface Component
    {
        get
        {
            if (_component != null)
            {
                _component = new MyImplementation();

                // ...
            }
            return _component;
        }
    }

    public void Dispose()
    {
        if (_component != null)
        {
            _component.Dispose();
        }
    }
}

ComponentExporter 是 MEF 实际创建的类，如果它实现了 IDisposable，那么 MEF 将随容器一起处置它。在此示例中，ComponentExporter 在释放时释放创建的组件，这可能正是您想要的。

当然，如果直接将导出放在 MyImplementation 类上会更容易。我假设您有一些原因不这样做，但这就是它的外观：

[Export(typeof(IMyInterface))]
public class MyImplementation : IMyInterface, IDisposable
{
    // ...
}

关于代码的一些其他注释：您可能不需要通过批处理将目录添加到容器中，除非您将其导入到某个地方并从容器内的部件对其进行修改。如果您碰巧要处理许多请求并且关心性能，则应该只创建一次 AssemblyCatalog，然后对所有请求使用同一个。

Answer 2

丹尼尔是对的。我将导入和导出的关系定义为映射类中的属性。我将它们作为 ComposablePartCatalog 加载到 MEF 的容器中，以便 MEF 可以神奇地动态获取相应的实例。在映射类中，我有一些到新实例的代码。因此，我必须想办法让MEF在退出进程时回调那些映射类来处理创建的资源。

我喜欢丹尼尔的建议，为我的导出部分引入一个类。由于我所有的 DI 映射都是以属性（getter 和 setter）的方式定义的，所以我创建了一个如下的基类：

public class ComponentExporterBase: IDisposable {
  private List<IDisposable> _list;

  public ComponentExporterBase()  {
    _list = new List<IDisposable>();
  }

  protect void Add(IDisposable obj) {
    _list.Add(obj);
  }

  protected virtual void Dispose(bool disposing) {
    if (disposing) {
      foreach(var obj in _list) {
        obj.Dispose();
      }
      _list.Clear();
    }
  }  

  public void Dispose()  {
    Dispose(true);
  }
}

有了这个基类，我的映射类将能够让 MEF 来完成处理工作。例如，这里有一个例子：

internal class MyDIMappingClass : ComponentExporterBase {
  [Import]
  private IDataReader _dataReader { get; set; }

  [Export]
  private IController {
      get {
         var reader = _dataReader;
         var instance = new MyMainController(reader);
         base.Add(instance);
         return instance;
  }
  ...
}

我所有的映射类都是以类似的方式定义的，而且它们更干净。基本原则是在类中创建的实例或资源应该在类中处理，但不能在注入的实例中处理。这样，我就不再需要通过 MEF 清理任何注入的实例，如本例所示：

public class MyMainController : IController {
   private IDataReader _dataReader;

   // dataReader is injected through CTOR
   public MyMainControler(IDataReader dataReader) {
     _dataReader = dataReader; 
     ...
   }
   ...
   public void Dispose() {
     // dispose only resources created in this class
     // _dataReader is not disposed here or within the class!
     ...}
}

顺便说一句，我喜欢使用属性作为我的导入和导出，因为属性与类的业务无关逻辑。在其他许多情况下，某些类来自第三方，我无法访问它们的源代码以将它们标记为导出。