• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

C#高级编程9第30章MEFC#可扩展编程之MEF第2章(抄录)

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

Managed Extensibility Framework (MEF)

 

什么是 MEF？
 　　Managed Extensibility Framework 即 MEF 是用于创建轻量、可扩展应用程序的库。 它让应用程序开发人员得以发现和使用扩展且无需配置。 它还让扩展开发人员得以轻松地封装代码并避免脆弱的紧密依赖性。 MEF 让扩展不仅可在应用程序内重复使用，还可以跨程序重复使用。
 

实例：

MEF 位于 ComponentModel.Composition 程序集中

添加 System.ComponentModel.Composition 和 System.ComponentModel.Composition.Hosting 的项目引用

 

 ImportAttribute  属性声明了某些操作为导入；在撰写对象时，它将由组合引擎进行填写。

 ImportAttribute 属性由且只能由 ExportAttribute 填写。 如果可用数目超过一，则组合引擎生成错误。 你可以使用 ImportManyAttribute 属性来创建可由任意数目的导出填写的导入

Lazy<T, TMetadata> 是由 MEF 提供来保存对导出的间接引用的类型。 除了导出对象本身，你还可以获取导出元数据或描述导出对象的信息。 每个Lazy<T, TMetadata> 都包含一个代表实际操作的 IOperation 对象和一个代表元数据的 IOperationData 对象。

ExportAttribute 属性函数和之前一致。ExportMetadataAttribute 属性将采用名称值对形式的元数据附加到导出

DirectoryCatalog 将把在扩展目录中的所有程序集中发现的部件添加到撰写容器中。

MEF 组合模型的核心是包含所有可用部件并执行撰写的撰写容器。 （它是对导入到导出进行的匹配。） 撰写容器最常用的类型是CompositionContainer

 

MEF使用实例

 

接口定义：

[csharp] view plain copy
 
 
  1. namespace Interface  
  2. {  
  3.     public interface IBookService  
  4.     {  
  5.         void GetBookName();  
  6.     }  
  7. }  


针对于接口的3个实现，如下代码所示：

[csharp] view plain copy
 
 
  1. using System;  
  2. using System.ComponentModel.Composition;  
  3. using Interface;  
  4.   
  5.   
  6. namespace ComputerBookServiceImp  
  7. {  
  8.     [Export(typeof(IBookService))]  
  9.     public class ComputerBookService : IBookService  
  10.     {  
  11.         public void GetBookName()  
  12.         {  
  13.             Console.WriteLine("Computer Book");  
  14.         }  
  15.     }  
  16. }  


上面代码除了对接口的实现以外，有两点需要说明的：
1、项目中引用了System.ComponentModel.Composition程序集，使用MEF必须使用该程序集。
2、使用了Export特性标记了ComputerBookService类，并且声明其类型为IBookServivce，通过此特性说明该类是MEF的一个导出部件。

其他两个版本的实现和上面雷同，代码如下：

HistoryBookServiceImp

[csharp] view plain copy
 
 
  1. using System;  
  2. using System.ComponentModel.Composition;  
  3. using Interface;  
  4.   
  5.   
  6. namespace HistoryBookServiceImp  
  7. {  
  8.     [Export(typeof(IBookService))]  
  9.     public class HistoryBookService : IBookService  
  10.     {  
  11.         public void GetBookName()  
  12.         {  
  13.             Console.WriteLine("History Book");  
  14.         }  
  15.     }  
  16. }  


MathBookServiceImp

[csharp] view plain copy
 
 
  1. using System;  
  2. using System.ComponentModel.Composition;  
  3. using Interface;  
  4.   
  5.   
  6. namespace MathBookServiceImp  
  7. {  
  8.     [Export(typeof(IBookService))]  
  9.     public class MathBookService : IBookService  
  10.     {  
  11.         public void GetBookName()  
  12.         {  
  13.             Console.WriteLine("Math Book");  
  14.         }  
  15.     }  
  16. }  


然后在修改控制台应用程序Proggram类的代码如下所示：

[csharp] view plain copy
 
 
  1. using System.ComponentModel.Composition;  
  2. using System.ComponentModel.Composition.Hosting;  
  3. using Interface;  
  4.   
  5.   
  6. namespace HostApp  
  7. {  
  8.     class Program  
  9.     {  
  10.         static void Main(string[] args)  
  11.         {  
  12.             Program program = new Program();  
  13.             program.Compose();  
  14.             program.BookService.GetBookName();  
  15.         }  
  16.   
  17.   
  18.         [Import]  
  19.         public IBookService BookService { get; set; }  
  20.   
  21.   
  22.         /// <summary>  
  23.         /// 通过容器对象将宿主和部件组装到一起。  
  24.         /// </summary>  
  25.         public void Compose()  
  26.         {  
  27.             DirectoryCatalog directoryCatalog = new DirectoryCatalog("imps");  
  28.             var container = new CompositionContainer(directoryCatalog);  
  29.             container.ComposeParts(this);  
  30.         }  
  31.     }  
  32. }  


上面的代码有3点需要说明：
1、通过Import特性标记BookService为一个导入属性，这样MEF的容器在进行宿主和部件组装的时候，将会查找与之匹配的导出部件，然后进行组装。上述代码所查找的是类型与BooService类型相同的导出部件。
2、通过使用DirectoryCatalog类指明要查找的导出部件位于应用程序根目录下的imps子文件夹中。
3、通过CompositionContainer的扩展方法ComposeParts()组装宿主程序和导出部件。在该方法执行前，BookService属性值为null，运行后，如果找到匹配的导出部件，则创建了该导出部件的一个实例。

MEF导入导出遵守协议一致

 

包含协议名和类型的导出：

[csharp] view plain copy
 
 
  1. [Export("SQL", typeof(ILogger))]  
  2. public class SqlLogger : ILogger  
  3. {  
  4.     public void WriteLog(string message)  
  5.     {  
  6.         Console.WriteLine("SQL Logger => {0}", message);  
  7.     }  
  8. }  

其中Export的第一个参数是协议名称，第二个参数则是导出的类型。对应的导入代码如下：

[csharp] view plain copy
 
 
  1. [Import("SQL", typeof(ILogger))]  
  2. public ILogger SqlLogger { get; set; }  


只包含导出协议名的导出：

[csharp] view plain copy
 
 
  1. [Export("Oracal")]  
  2. public class OracalLogger : ILogger  
  3. {  
  4.     public void WriteLog(string message)  
  5.     {  
  6.         Console.WriteLine("Oracal Logger => {0}", message);  
  7.     }  
  8. }  

上述导出协议并未指定导出类型，因此就以所修饰类作为其导出类型，即OracalLogger。相应的导入代码为：

[csharp] view plain copy
 
 
  1. [Import("Oracal")]  
  2. public OracalLogger OracalLogger { get; set; }  

其中属性的类型是OracalLogger，而不是ILogger。如果类型为ILogger，导入就会失败。


只包含导出类型的导出：

[csharp] view plain copy
 
 
  1. [Export(typeof(ILogger))]  
  2. public class TxtLogger : ILogger  
  3. {  
  4.     public void WriteLog(string message)  
  5.     {  
  6.         Console.WriteLine("Text Logger => {0}", message);  
  7.     }  
  8. }  

上述导出协议未指定导出协议名称，只指定了导出类型。则相应的导入代码为：

[csharp] view plain copy
 
 
  1. [Import(typeof(ILogger))]  
  2. public ILogger TextLogger { get; set; }  


既不包含导出类型，也不包含导出协议名称的导出：

[csharp] view plain copy
 
 
  1. [Export]  
  2. public class XmlLogger : ILogger  
  3. {  
  4.     public void WriteLog(string message)  
  5.     {  
  6.         Console.WriteLine("Xml Logger => {0}", message);  
  7.     }  
  8. }  

上述代码的导出协议名为默认协议，类型则与所修改的类相同，即XmlLogger，与之匹配的导入代码应该如下所示：

[csharp] view plain copy
 
 
  1. [Import]  
  2. public XmlLogger XmlLogger { get; set; }  


务必确保导入属性XmlLogger的属性类型与导出特性修饰的类型保持一致，否则导入失败。

 

MEF延迟加载

 

延迟加载在导出部件处的设置没什么变化，保持原有的设置即可。如下代码所示：

[csharp] view plain copy
 
 
  1. [Export("Oracal", typeof(ILogger))]  
  2. public class OracalLogger : ILogger  
  3. {  
  4.     public void WriteLog(string message)  
  5.     {  
  6.         Console.WriteLine("Oracal Logger => {0}", message);  
  7.     }  
  8. }  

在导入的时候，需要使用.NET提供的Lazy类来完成。代码如下：

[csharp] view plain copy
 
 
  1. [Import("Oracal", typeof(ILogger))]  
  2. public Lazy<ILogger> OracalLogger { get; set; }  

通过Lazy封装的对象即自动提供了延迟加载的机制。访问对象的方式也略微有所改变，当然不能直接通过属性（上例中的OracalLogger）进行访问，而是需要通过Lazy<T>.Value来访问，此属性值包含的即使延迟加载的对象。
另外Lazy<T>.IsValueCreated属性提供了判断对象是否加载的功能，如果为true则表示对象已加载，否则为未加载。

 

MEF元数据

关于MEF的数据的使用，首先需要给导出部件添加ExportMetadata特性，用来设置要添加的元数据。如下面代码所示：

[csharp] view plain copy
 
 
  1. [ExportMetadata("Name", "Xml")]  
  2. [ExportMetadata("Description", "使用的是XML来记录日志")]  
  3. [Export("Xml", typeof(ILogger))]  
  4. public class XmlLogger : ILogger  
  5. {  
  6.     public void WriteLog(string message)  
  7.     {  
  8.         Console.WriteLine("Xml Logger => {0}", message);  
  9.     }  
  10. }  

如上代码所示，首先ExportMetadata特性可以被重复的添加到多个多出部件，另外，该特性的两个参数非常的类似于键值对，第一个参数为元数据的名称，第二个参数则是元数据的实际内容。
至此，导出部件所需要做的修改就算是完成了。接下来，就该修改导入了。如下代码所示：

[csharp] view plain copy
 
 
  1. [Import("Xml", typeof(ILogger))]  
  2. public Lazy<ILogger, IMetadata> XmlLogger { get; set; }  

如上代码所示，仍然使用的Lazy类。其中第二个泛型参数表示的就是元数据的接口。定义大致如下：

[csharp] view plain copy
 
 
  1. public interface IMetadata  
  2. {  
  3.     string Description { get; }  
  4.     string Name { get; }  
  5. }  

仔细对比后会发现，该接口中的成员名称和导出部件中的元数据名称是如此的一致。实是上不仅其名称要保持一致，连数据类型也要保持一致，否则导入的时候将会引发异常。

经过如上的代码修改后，通过导入元素（上例中的XmlLogger属性）会有一个名为Metadata的属性，即Lazy<T, TMeta>.Metadata，通过它即可访问导出部件中的各个元数据了。
如下代码所示：

[csharp] view plain copy
 
 
    1. Console.WriteLine(program.XmlLogger.Metadata.Name);  
    2. Console.WriteLine(program.XmlLogger.Metadata.Description);  

MEF多部件导入ImportMany

 

部件的导出设置不做任何改变，将导入地方做类似如下的修改：

[csharp] view plain copy
 
 
  1. [ImportMany(typeof(ILogger))]  
  2. public IEnumerable<ILogger> Loggers { get; set; }  

上述代码和单个部件的导入有两点区别：
1、使用ImportMany特性，而不是Import特性。
2、使用的是IEnumerable<T>类型来封装导入的部件。因为，导入的可能是多个部件，需要一种集合的方式来承载。

导入元素做了如上的修改后，调用时只需要遍历即可访问每个导出部件。如下代码所示：

[csharp] view plain copy
 
 
    1. static void Main(string[] args)  
    2. {  
    3.     Program program = new Program();  
    4.     program.Compose();  
    5.     foreach (ILogger logger in program.Loggers)  
    6.     {  
    7.         logger.WriteLog("Hello World!");  
    8.     }  
    9.     Console.ReadLine();  
    10. }  

MEF目录服务（Catalog）

 

在MEF中，所谓的目录（Catalog）是不同于文件系统中的目录（Directory），而它的作用就是告知MEF框架可以在什么地方去查找导出部件，比如：
AssemblyCatalog：在指定的程序集中查找导出部件。
DirectoryCatalog：在指定的文件目录中查找导出部件，在构造函数中可传递文件目录，可以是绝对路径或相对路径。
代码如下：

[csharp] view plain copy
 
 
  1. /// <summary>  
  2. /// 通过容器对象将宿主和部件组装到一起。  
  3. /// </summary>  
  4. public void Compose()  
  5. {  
  6.     AggregateCatalog aggregateCatalog = new AggregateCatalog();  
  7.     AssemblyCatalog assemblyCatalog = new AssemblyCatalog(typeof(Program).Assembly);  
  8.     DirectoryCatalog directoryCatalog = new DirectoryCatalog("imps");  
  9.     aggregateCatalog.Catalogs.Add(assemblyCatalog);  
  10.     aggregateCatalog.Catalogs.Add(directoryCatalog);  
  11.     var container = new CompositionContainer(aggregateCatalog);  
  12.     container.ComposeParts(this);  
  13. }  

上述代码中有一个AggregateCatalog的目录类，这是一个聚合目录，它可以将多个目录组织在一起，比如上列中的AssemblyCatalog和DirectoryCatalog。这样，MEF就会在多个地方去搜寻匹配的导出部件。

MEF自定义部件目录类Catalog

 

在MEF中，除了可以使用自身提供的注入AggregateCatalog、AssemblyCatalog、DirectoryCatalog这样的目录类以外，也可以自己定义目录类。
自定义目录类需要继承自ComposablePartCatalog类，并实现接口INotifyComposablePartCatalogChanged即可。如下面所示的代码：

[csharp] view plain copy
 
 
  1. public class FilteredCatalog : ComposablePartCatalog, INotifyComposablePartCatalogChanged  
  2. {  
  3.     #region Private Fields  
  4.   
  5.   
  6.     private readonly ComposablePartCatalog m_ComposablePartCatalog;  
  7.     private readonly INotifyComposablePartCatalogChanged m_NotifyComposablePartCatalogChanged;  
  8.     private readonly IQueryable<ComposablePartDefinition> m_Parts;  
  9.  
  10.  
  11.     #endregion  
  12.  
  13.  
  14.     #region Constructors  
  15.   
  16.   
  17.     /// <summary>  
  18.     /// 默认构造函数。  
  19.     /// </summary>  
  20.     /// <param name="composablePartCatalog">包含了所有导出部件的目录Catalog。</param>  
  21.     /// <param name="expression">筛选条件表达式。</param>  
  22.     public FilteredCatalog(ComposablePartCatalog composablePartCatalog, Expression<Func<ComposablePartDefinition, bool>> expression)  
  23.     {  
  24.         m_ComposablePartCatalog = composablePartCatalog;  
  25.         m_NotifyComposablePartCatalogChanged = composablePartCatalog as INotifyComposablePartCatalogChanged;  
  26.         m_Parts = composablePartCatalog.Parts.Where(expression);  
  27.     }  
  28.  
  29.  
  30.     #endregion  
  31.  
  32.  
  33.     #region INotifyComposablePartCatalogChanged  
  34.   
  35.   
  36.     /// <summary>  
  37.     /// 部件目录Catalog已经改变后触发的事件。  
  38.     /// </summary>  
  39.     public event EventHandler<ComposablePartCatalogChangeEventArgs> Changed  
  40.     {  
  41.         add  
  42.         {  
  43.             if (m_NotifyComposablePartCatalogChanged != null)  
  44.             {  
  45.                 m_NotifyComposablePartCatalogChanged.Changed += value;  
  46.             }  
  47.         }  
  48.         remove  
  49.         {  
  50.             if (m_NotifyComposablePartCatalogChanged != null)  
  51.             {  
  52.                 m_NotifyComposablePartCatalogChanged.Changed -= value;  
  53.             }  
  54.         }  
  55.     }  
  56.   
  57.   
  58.     /// <summary>  
  59.     /// 部件目录Catalog正在发生改变时触发的事件。  
  60.     /// </summary>  
  61.     public event EventHandler<ComposablePartCatalogChangeEventArgs> Changing  
  62.     {  
  63.         add  
  64.         {  
  65.             if (m_NotifyComposablePartCatalogChanged != null)  
  66.             {  
  67.                 m_NotifyComposablePartCatalogChanged.Changing += value;  
  68.             }  
  69.         }  
  70.         remove  
  71.         {  
  72.             if (m_NotifyComposablePartCatalogChanged != null)  
  73.             {  
  74.                 m_NotifyComposablePartCatalogChanged.Changing -= value;  
  75.             }  
  76.         }  
  77.     }  
  78.  
  79.  
  80.     #endregion  
  81.  
  82.  
  83.     #region ComposablePartCatalog  
  84.   
  85.   
  86.     /// <summary>  
  87.     /// 获取目录中包含的部件定义。经过构造函数中的表达式过滤后，已经是传入目录Catalog对象中的一部分导出部件了。  
  88.     /// </summary>  
  89.     public override IQueryable<ComposablePartDefinition> Parts  
  90.     {  
  91.         get { return m_Parts; }  
  92.     }  
  93.  
  94.  
  95.     #endregion  
  96. }  

上述代码中概括来说包含如下几点内容：
1、构造函数传递了基础目录Catalog对象，这个目录对象可能包含了很多的导出部件，我们要实现的目录过滤类FilteredCatalog就是基于这个目录进行过滤的，它是个全集，而FilteredCatalog是它的子集。另外一个参数是过滤表达式，过滤条件由调用者来编写，至于内部过滤办法实际还是LINQ提供的Where()方法。
2、对于接口INotifyComposablePartCatalogChanged的实现，实际上是和基础目录Catalog对象的事件关联在一起，即当基础目录对象发生改变时，目录过滤类FilteredCatalog也将会收到相应的通知。
3、重写了基类ComposablePartCatalog的Parts集合属性，该属性返回的就是该目录中包含部件定义，凡是在目录中需要被暴露的部件定义都是通过该集合返回的。因此，上述代码中将过滤后的部件定义通过该属性返回。

定义好了过滤类，接下来就是如何使用它了。

三、使用自定义目录类Catalog
如下代码所示：

[csharp] view plain copy
 
 
  1. // 获取所需的部件。  
  2. DirectoryCatalog catalog = new DirectoryCatalog("controls");  
  3. CompositionContainer container = new CompositionContainer(catalog);  
  4.   
  5.   
  6. // 过滤Catalog，生成子组合容器。  
  7. FilteredCatalog filteredCatalog = new FilteredCatalog(catalog,  
  8.     o=>o.Metadata.ContainsKey("UC") && o.Metadata["UC"].ToString() == "BB");  
  9. CompositionContainer filteredContainer = new CompositionContainer(filteredCatalog, container);  
  10.   
  11.   
  12. UserControl userControl = filteredContainer.GetExportedValue<UserControl>();  
  13. this.MainContentControl.Content = userControl;  

首先通过DirectoryCatalog类获取到应用程序根目录下controls子文件夹中的所有部件定义，并以此生成顶级组合容器container（类型为CompositionContainer）。
然后使用自定义目录过滤类FilteredCatalog对DirectoryCatalog目录中的部件定义进行过滤，并生成子组合容器filteredContainer（类型为CompositionContainer）。
最后通过组合容器的GetExportedValue<T>()方法获取指定协议类型的导出部件。需要说明的是，如果组合容器中没有对应协议类型的导出部件则会引发异常。

 

MEF部件创建策略

 

MEF提供的导出部件的三种创建策略，分别如下：
CreationPolicy.Any：表示可共享或不共享，部件的实例用MEF容器根据不同的请求需求自动控制。
CreationPolicy.Shared表示共享部件，既Shared类型的插件部件可以在多个MEF组合容器中共用，而且多次请求该部件返回的其实是同一个对象。
CreationPolicy.NonShared类型，表示不共享部件实例，每当有新的请求就会创建一个新的对象实例。

三、关键代码
下面介绍了如何在导出部件中设置其创建策略，以及导入的时候如何使用。
通过为导出部件添加PartCreationPolicyAttribute特性，可指定其创建策略。代码如下：

[csharp] view plain copy
 
 
  1. [PartCreationPolicy(CreationPolicy.NonShared)]  
  2. [Export(typeof(UserControl))]  
  3. public partial class UserControlBB : UserControl  
  4. {  
  5.     public UserControlBB()  
  6.     {  
  7.         InitializeComponent();  
  8.     }  
  9. }  

在导出部件的时候，可设置导入指定创建策略的部件，比如下面的代码，只导入创建策略为CreationPolicy.Shared的导出部件。

[csharp] view plain copy
 
 
    1. [ImportMany(RequiredCreationPolicy = CreationPolicy.Shared)]  
    2. public List<UserControl> UserControls { get; set; }   

推荐链接：http://blog.csdn.net/gjysk/article/details/44648505

 

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
[C#基础]说说lock到底锁谁？（补充与修改）发布时间：2022-07-13
下一篇：
C# 互操作性入门系列(四)：在C# 中调用COM组件发布时间：2022-07-13
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap