对于简单的场景来讲，在MEF中导入依赖模块非常简单，只要用ImportAttribute标记依赖的成员，MEF模块会自动找到并创建该模块。但有的时候我们依赖的模块是上下文相关的，此时MEF框架的自动组装满足不了我们的需求了，这里以我之前的文章的一个Log插件为例：
class HostModule
{
[Import]
ILogger logger = null;
public
string Name { get; private
set; }
public HostModule(string name)
{
this.Name = name;
Compose();
logger.LogMessage("hello world");
}
void Compose()
{
var catalog = new
AssemblyCatalog(this.GetType().Assembly);
var container = new
CompositionContainer(catalog);
container.ComposeParts(this);
}
}
interface
ILogger
{
void LogMessage(string msg);
}
[Export(typeof(ILogger))]
class
ConsoleLogger : ILogger
{
public
void LogMessage(string msg)
{
Console.WriteLine(DateTime.Now + ": " + msg);
}
}
现在我想要在Log信息中加入模块名称作为前缀，改成如下形式：
[Export(typeof(ILogger))]
class
ConsoleLogger : ILogger
{
public
string ModuleName { get; private
set; }
public
void LogMessage(string msg)
{
Console.WriteLine(">> " + ModuleName + " | " + DateTime.Now + ": " + msg);
}
}
由于MEF框架不知道Logger.ModuleName和HostModule.Name的关系，无法直接通过ImportAttribute标记ModuleName属性搞定。那么，我们该如何传入这ModuleName呢？
通过构造函数导入：
这最直接想到的就是一种方式了，主要修改如下：
- 在插件模块中创建构造函数，参数为需要导入的依赖模块，并且用ImportingConstructorAttribute标记构造函数。
- 在构造函数中庸ImportAttribute标记参数
- 在组装函数中用ComposeExportedValue函数传入参数
示例代码如下：
class
HostModule
{
[Import]
ILogger logger = null;
public
string Name { get; private
set; }
public HostModule(string name)
{
this.Name = name;
Compose();
logger.LogMessage("hello world");
}
void Compose()
{
var catalog = new
AssemblyCatalog(this.GetType().Assembly);
var container = new
CompositionContainer(catalog);
container.ComposeExportedValue("ModuleName", this.Name);
container.ComposeParts(this);
}
}
interface
ILogger
{
void LogMessage(string msg);
}
[Export(typeof(ILogger))]
class
ConsoleLogger : ILogger
{
public
string ModuleName { get; private
set; }
[ImportingConstructor]
public ConsoleLogger([Import("ModuleName")] string moduleName)
{
this.ModuleName = moduleName;
}
public
void LogMessage(string msg)
{
Console.WriteLine(">> " + ModuleName + " | " + DateTime.Now + ": " + msg);
}
}
这种方式一个比较大的缺点就是麻烦，上面的例子还好，如果要导入的参数比较多就显得有点麻烦了。并且后续要新增一个依赖的模块的话则要同时修改好几处处地方，不够集中，容易改漏，并且也不容易排查错误。
在成员中导入
在成员中导入的方式如下：
- 在Host中用Export标记导出参数
- 在插件模块中用Import标记导入参数
修改后的代码如下，我把修改的地方标记了一下：
class
HostModule
{
[Import]
ILogger logger = null;
[Export("ModuleName")]
public
string Name { get; private
set; }
public HostModule(string name)
{
this.Name = name;
Compose();
logger.LogMessage("hello world");
}
void Compose()
{
var catalog = new
AssemblyCatalog(this.GetType().Assembly);
var container = new
CompositionContainer(catalog);
container.ComposeParts(this);
}
}
interface
ILogger
{
void LogMessage(string msg);
}
[Export(typeof(ILogger))]
class
ConsoleLogger : ILogger
{
[Import("ModuleName")]
public
string ModuleName { get; private
set; }
public
void LogMessage(string msg)
{
Console.WriteLine(">> " + ModuleName + " | " + DateTime.Now + ": " + msg);
}
}
这种方式改动更少更直观，扩展性也更强，要好用得多了。
进一步解除限制
前面这种方式非常方便，但有一个限制：功能模块是由MEF框架在组装的时候创建的。但是，有的时候，功能模块无法由MEF框架创建（例如在WPF程序中的UI对象，或者一些比较复杂的上下文相关对象），但是，这个时候我们如何手动导入依赖的外部模块呢？MEF框架本身也是提供了比较完善的解决方案的：在执行ComposeParts函数组装的时候将两个对象一并传入一起组装即可。
class
HostModule
{
ILogger logger = new
ConsoleLogger();
[Export("ModuleName")]
public
string Name { get; private
set; }
public HostModule(string name)
{
this.Name = name;
Compose();
logger.LogMessage("hello world");
}
void Compose()
{
var container = new
CompositionContainer();
container.ComposeParts(this, logger);
}
}
interface
ILogger
{
void LogMessage(string msg);
}
class
ConsoleLogger : ILogger
{
[Import("ModuleName")]
public
string ModuleName { get; private
set; }
public
void LogMessage(string msg)
{
Console.WriteLine(">> " + ModuleName + " | " + DateTime.Now + ": " + msg);
}
}
小结：虽然前面介绍的这三种方式看起来有不小差别，但归根结底只是不同的组装形式而已，只要掌握了MEF的组装原理，就可以非常*的组装我们所需要的模块，实现松耦合、简单化、模块化的程序。