记得前面老周写过在.net core 中使用 Composition 的烂文。上回老周给大伙伴们介绍的是一个“重量级”版本—— System.ComponentModel.Composition。应该说，这个“重量级”版本是.NET 框架中的“标配”。
很多东西都会有双面性，MEF 也一样，对于扩展组件灵活方便，同时也带来性能上的一些损伤。但这个损伤应只限于应用程序初始化阶段，一般来说，我们也不需要频繁地去组合扩展，程序初始化时执行一次就够了。所以，性能的影响应在开始运行的时候。
与“重量级”版本在同一天发布的，还有一个“轻量级”版本—— System.Composition。相对于“标配”，这个库简洁了许多，与标准 MEF 相比，使用方法差不多，只是有细微的不同，这个老周稍后会讲述的，各位莫急。还有一个叫 Microsoft.Composition 的库，这个是旧版本的，适用于 Windows 8/8.1 的应用。对于 Core，可以不考虑这个版本。
System.Composition 相对于标准的 MEF，是少了一些功能的，尤其是对组件的搜索途径，MEF 的常规搜索途径有：应用程序范围、程序集范围、目录（文件夹）范围等。而“轻量级”版本只在程序集范围中搜索。这也很适合.net core 程序，尤其是 Web 项目。
好了，以上内容皆是纸上谈 B，下面咱们说干货。
1、安装需要的 NuGet 包
虽然在官方 docs 上，.net core API 目录收录了 System.Composition ，但默认安装的 .net core 库中是不包含 System.Composition 的，需要通过 Nuget 来安装。在 Nuget 上搜索 System.Composition，你会看到有好几个库。
那到底要安装哪个呢？很简单，选名字最短那个，其他几个因为存在依赖关系，会自动安装的。
这里老周介绍用命令来安装，很方便。在 VS 主窗体中，打开菜单【工具】-【NuGet 包管理器】-【程序包管理器控制台】，这样你就打开了一个命令窗口，然后输入：
Install-Package System.Composition
需要说的，输入的内容是不区分大小写的，你可以全部输入小写。这风格是很 PowerShell 的，这个很好记，PS 风格的命令都是“动词 + 名词”，中间一“减号”，比如，Get-Help。所以，安装的单词是 Install，程序包是 Package，安装包就是 Install-Package，然后你可以猜一下，那么卸载 Nuget 包呢，Uninstall-Package，那更新呢，Update-Package，查找包呢，Find-Package……
你要是不信，可以执行一下 get-help Nuget 看看。
好了，执行完对 System.Composition 的安装，它会自动把依赖的库也安装。
不带其他参数的 install-package ，默认会安装最新版本的库，所以说，执行这个来安装很方便。
2、导出类型
类型的导出方法与标准的 MEF 一样的，比如这样。
[Export] public class FlyDisk
{
}于是，这个 FlyDisk 类就被导出了。你也可以为导出设置一个协定名，在合并组件后方便挑选。
[Export("fly")] public class FlyDisk
{
}当然了，如果你的组件扩展模式是 接口 + 实现，通常为了兼容和规范，应该有个接口。这时候你标注 Export 特性时，要指明协定的 Type。
[Export(typeof(IPerson))] public class BaiLei : IPerson
{ public string Name => "败类";
}如果你希望更严格地约束导入和导出协定，还可以同时指定 Name 和 Type。
[Export("rz", typeof(IPerson))] public class RenZha : IPerson
{ public string Name => "人渣";
}
3、构建容器
在组装扩展时，需要一个容器，用来导入或收集这些组件，以供代码调用。在“轻量级”版本中，容器的用法与标准的 MEF 区别较大，MEF 中用的是 CompositionContainer 类，但在 System.Composition 中，我们需要先创建一个 ContainerConfiguration，然后再创建容器。容器由 CompositionHost 类表示。
来，看个完整的例子。首先是导出类型。
public interface IPerson
{ string Name { get; } void Work();
}
[Export(typeof(IPerson))] public class BaiLei : IPerson
{ public string Name => "败类"; public void Work()
{
Console.WriteLine("影响市容。");
}
}
然后，创建 ContainerConfiguration。
ContainerConfiguration config = new ContainerConfiguration().WithAssembly(Assembly.GetExecutingAssembly());
ContainerConfiguration 类的方法，调用风格也很像 ASP.NET Core，WithXXX 方法会把自身实例返回，以方便连续调用。上面代码是设置查找扩展组件的程序集，这里我设定为当前程序集，如果是其他程序集，可以用 Load 或 LoadFrom 方法先加载程序集，然后再调用 WithAssembly 方法，原理差不多。
随后，便可以创建容器了。
using(CompositionHost host = config.CreateContainer())
{
}调用 GetExport 方法可以直接获取到导出类型的实例。
using(CompositionHost host = config.CreateContainer())
{
IPerson p = host.GetExport<IPerson>();
Console.Write($"{p.Name}，");
p.Work();
}
那，如果某个协定接口有多个实现类导出呢。咱们再看一例。
首先，定义公共的协定接口。
public interface ICD
{ void Play();
}再定义两个导出类，都实现上面定义的接口。
[Export(typeof(ICD))] public class DbCD : ICD
{ public void Play()
{
Console.WriteLine("正在播放盗版 CD ……");
}
}
[Export(typeof(ICD))] public class BlCD : ICD
{ public void Play()
{
Console.WriteLine("正在播放蓝光 CD ……");
}
}
然后，跟前一个例子一样，创建 ContainerConfiguration 实例，再创建容器。
Assembly curAssembly = Assembly.GetExecutingAssembly();
ContainerConfiguration cfg = new ContainerConfiguration();
cfg.WithAssembly(curAssembly); using(CompositionHost host = cfg.CreateContainer())
{
……
}
接下来就是区别了，因为实现 ICD 接口并且标记为导出的类有两个，所以要调用 GetExports 方法。
using(CompositionHost host = cfg.CreateContainer())
{
IEnumerable<ICD> cds = host.GetExports<ICD>(); foreach (ICD c in cds)
c.Play();
}返回来的是一个 ICD （实际是 ICD 的实现类，但以 ICD 作为约束）列表，然后就可以逐个去调用了。结果如下图所示。
4、导入类型
导入的时候，除了调用 GetExport 方法外，还可以定义一个类，然后把类中的某个属性标记为由导入的类型填充。
看例子。先上接口。
public interface IAnimal
{ void Eating();
}然后上实现类，并标为导出类型。
[Export(typeof(IAnimal))] public class Dog : IAnimal
{ public void Eating()
{
Console.WriteLine("狗吃 Shi");
}
}
定义一个类，它有一个 MyPet 属性，这个属性由 Composition 来导入类型实例，并赋给它。
public class PeopleLovePets
{ [Import] public IAnimal MyPet { get; set; }
}注意有一点很重要，MyPet 属性上一定要加上 Import 特性，因为 Composition 在组装类型时会检测是否存在 Import 特性，如果你不加的话，扩展组件就不会导入到 MyPet 属性上的。
接着，创建容器的方法与前面一样。
ContainerConfiguration cfg = new ContainerConfiguration()
.WithAssembly(Assembly.GetExecutingAssembly()); PeopleLovePets pvl = new PeopleLovePets(); using(var host = cfg.CreateContainer())
{ host.SatisfyImports(pvl); }
但你会看到有差别的，这一次，要先创建 PeopleLovePets 实例，后面要调用 SatisfyImports 方法，在 PeopleLovePets 实例上组合导入的类型。
最后，你通过 MyPet 属性就能访问导入的对象了，以 IAnimal 为规范，实际类型是 Dog。
IAnimal an = pvl.MyPet; an.Eating();
那，如果导出的类型是多个呢，这时就不能只用 Import 特性了，要用 ImportMany 特性，而且接收导入的 MyPet 属性要改为 IEnumerable<IAnimal>，表示多个实例。
public class PeopleLovePets
{ [ImportMany] public IEnumerable<IAnimal> MyPet { get; set; }
}为了应对这种情形，我们再添加一个导出类型。
[Export(typeof(IAnimal))] public class Cat : IAnimal
{ public void Eating()
{
Console.WriteLine("猫吃兔粮");
}
}
创建容器和执行导入的处理过程都不变，但访问 MyPet属性的方法要改了，因为现在它引用的不是单个实例了。
foreach (IAnimal an in pvl.MyPet) an.Eating();
5、导出元数据
元数据不是类型的一部分，但可以作为类型的附加信息。有些时候是需要的，尤其是在实际使用时，Composition 组合它所找到的各种扩展组件，但在调用时，可能不会全部都调用，需要筛选出需要调用的那部分。
为导出类型添加元数据有两种方法。先说第一种，很简单，直接在导出类型上应用 ExportMetadata 特性，然后设置 Name 和 Value，每个 ExportMetadataAttribute 实例就是一条元数据，你会发现，它其实很像 key / value 结构。
看个例子，假设有这样一个公共接口。
public interface IMail
{ void ReadBody(string from);
}然后有两个导出类型。
[Export(typeof(IMail))] public class MailLoader1 : IMail
{ public void ReadBody(string from)
{
Console.WriteLine($"Pop3：来自{from}的邮件");
}
}
[Export(typeof(IMail))] public class MailLoader2 : IMail
{ public void ReadBody(string from)
{
Console.WriteLine($"IMAP：来自{from}的邮件");
}
}
这两种类型所处理的逻辑是不同的，第一个是通过 POP3 收到的邮件，第二个是通过 IMAP 收到的邮件。为了在导入类型后能够进行判断和区分，可以为它们分别附加元数据。
[Export(typeof(IMail))]
[ExportMetadata("prot", "POP3")] public class MailLoader1 : IMail
{
……
}
[Export(typeof(IMail))]
[ExportMetadata("prot", "IMAP")] public class MailLoader2 : IMail
{
……
}
在导入带元数据的类型时，可以用到这个类——Lazy<T, TMetadata>，它是 Lazy<T> 的子类，类如其名，就是延迟初始化的意思。
定义一个 MailReader 类，公开一个 Loaders 属性。
public class MailReader
{
[ImportMany] public IEnumerable<Lazy<IMail, IDictionary<string, object>>> Loaders { get; set; }
}注意这里，Lazy 的 TMetadata，默认的实现，通过 IDictionary<string, object> 是可以存储导入的元数据的。上面咱们也看到，元数据在导出时，是以 Name / Value 的方式指定的，相当类似于字典的结构，所以，用字典数据类型自然就能存放导入的元数据。
执行导入的代码就很简单了，跟前面的例子差不多。
ContainerConfiguration cfg = new ContainerConfiguration()
.WithAssembly(Assembly.GetExecutingAssembly());
MailReader mlreader = new MailReader(); using(CompositionHost host = cfg.CreateContainer())
{
host.SatisfyImports(mlreader);
}
这时候，我们在访问导入的类型时，就可以根据元数据进行筛选了。
在这个例子中，咱们只调用带 IMAP 的邮件阅读器。
IMail m = (from o in mlreader.Loaders
let t = o.Metadata["prot"] as string
where t == "IMAP"
select o).First().Value;
m.ReadBody("da_sb@ppav.com");最后调用的结果如下
IMAP：来自da_sb@ppav.com的邮件
当然了，元数据还有更高级的玩法，你要是觉得附加 N 条 ExportMetadata 特性太麻烦，你还可以自己定义一个类来包装，注意在这个类上要标记 MetadataAttribute 特性，而且从 Attribute 类派生。为啥呢？因为元数据是不参与类型逻辑的，你要把它附加到类型上，只能作为 特性 来处理。
[AttributeUsage(AttributeTargets.Class)]
[MetadataAttribute] public class ExtMetadataInfoAttribute : Attribute
{ public string Remarks { get; set; } public string Author { get; set; } public string PublishTime { get; set; }
}
之后，就可以直接应用到导出类型上面了。
public interface ITest
{ void RunTask();
}
[Export(typeof(ITest))]
[ExtMetadataInfo(Author = "单眼明", PublishTime = "2018-9-18", Remarks = "已 debug 了 71125 次")] public class DemoComp : ITest
{ public void RunTask()
{
Console.WriteLine("Demo 组件被调用");
}
}
[Export(typeof(ITest))]
[ExtMetadataInfo(Author = "大神威", PublishTime = "2018-10-5", Remarks = "预览版")] public class PlainComp : ITest
{ public void RunTask()
{
Console.WriteLine("Plain 组件被调用");
}
}
导入时，同样可以 import 到一个属性中。
public class MyAppPool
{
[ImportMany] public IEnumerable<Lazy<ITest, IDictionary<string, object>>> Components { get; set; }
}创建容器的方法一样。
ContainerConfiguration cfg = new ContainerConfiguration()
.WithAssembly(Assembly.GetExecutingAssembly());
MyAppPool pool = new MyAppPool(); using(var host = cfg.CreateContainer())
{
host.SatisfyImports(pool);
}
尝试枚举出导入类型的元数据。
foreach (var ext in pool.Components)
{ var metadata = ext.Metadata;
Console.WriteLine($"{ext.Value.GetType()} 的元数据："); foreach (var kv in metadata)
{
Console.WriteLine($"{kv.Key}: {kv.Value}");
}
Console.WriteLine();
}
执行结果如下图。
要是你觉得用 IDictionary<string, object> 类型来存放导入的元数据也很麻烦，那你也照样可以定义一个类来存放，但这个类要符合两点：a、带有无参数的公共构造函数，因为它是由 Composition 内部来实例化的；b、属性必须是公共并且有 get 和 set 访问器，即可写的，不然没法设置值了，而且属性名必须与导出时的元数据名称相同。
现在我们改一下刚刚的例子，定义一个类来存放导入的元数据。
public class ImportedMetadata
{ public string Author { get; set; } public string Remarks { get; set; } public string PublishTime { get; set; }
}然后，MyAppPool 类也可以改一下。
public class MyAppPool
{ //[ImportMany] //public IEnumerable<Lazy<ITest, IDictionary<string, object>>> Components { get; set; } [ImportMany] public IEnumerable<Lazy<ITest, ImportedMetadata>> Components { get; set; }
}
最后，枚举元数据的代码也改一下。
foreach (var ext in pool.Components)
{ var metadata = ext.Metadata;
Console.WriteLine($"{ext.Value.GetType()} 的元数据：");
Console.WriteLine($"Author: {metadata.Author}\nRemarks: {metadata.Remarks}\nPublishTime: {metadata.PublishTime}");
Console.WriteLine();
}
====================================================================
好了，关于 System.Composition，今天老周就介绍这么多，内容也应该覆盖得差不多了。肚子饿了，准备开饭。
原文出处：https://www.imooc.com/article/43829
共同学习，写下你的评论
评论加载中...
作者其他优质文章
