【.NET 深呼吸】.net core 中的轻量级 Composition

记得前面老周写过在.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,今天老周就介绍这么多,内容也应该覆盖得差不多了。肚子饿了,准备开饭。 

posted @ 2018-09-09 12:06  东邪独孤  阅读(...)  评论(...编辑  收藏