扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >C#在MEF框架中实现延迟加载部件
  • 530

0
分享到

C#在MEF框架中实现延迟加载部件

2024-04-02 19:04:59 530人浏览 安东尼
摘要

在MEF的宿主中，当我们通过Import声明导入的对象时，组装（Compose）的时候会创建该对象。例如： interface ILogger { v

在MEF的宿主中，当我们通过Import声明导入的对象时，组装（Compose）的时候会创建该对象。例如：

    interface ILogger
    {
        void Log(string message);
    }

    [Export(typeof(ILogger))]
    class ConsoleLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine("logger 1" + message);
        }
    }

    class Host
    {
        [Import]
        ILogger _logger = null;

        public Host()
        {
            var catalog = new AssemblyCatalog(this.GetType().Assembly);
            var container = new CompositionContainer(catalog);

            //这儿会创建ConsoleLogger对象
            container.ComposeParts(this);

            _logger.Log("hello world");
        }
    }

有的时候，有些组件的创建开销比较大，但又不会立即使用。此时，我们希望通过延迟初始化的方式将其延迟到使用的时候创建，从而提高性能（常见的是提高启动速度）。MEF是支持这一模式的，我们只需要修改一下导入的声明形式即可。

    [Import]
    Lazy<ILogger> _logger = null;

这样，Logger就会延迟到第一次使用的时候创建了。

元数据MetaData

有的时候，对于同一个服务有多个提供者，我们需要从中选择一个使用。MEF提供了ImportMany来解决这一需求。

有的时候，对于同一个服务有多个提供者，我们需要从中选择一个使用。MEF提供了ImportMany来解决这一需求。

    [Export(typeof(ILogger))]
    class ConsoleLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine(message);
        }
    }

    [Export(typeof(ILogger))]
    class DbLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine(message);
        }
    }

    class Host
    {
        [ImportMany]
        ILogger[] _logger = null;


        public Host()
        {
            var catalog = new AssemblyCatalog(this.GetType().Assembly);
            var container = new CompositionContainer(catalog);

            container.ComposeParts(this);

            _logger.FirstOrDefault(i => i is DbLogger).Log("hello world");
        }
    }

此时，如果我们想使用延迟导入的时候，就会变成如下形式：

    class Host
    {
        [ImportMany]
        Lazy<ILogger>[] _loggerServices = null;

        public Host()
        {
            var catalog = new AssemblyCatalog(this.GetType().Assembly);
            var container = new CompositionContainer(catalog);

            //这儿会创建ConsoleLogger对象
            container.ComposeParts(this);

            _loggerServices.FirstOrDefault(i => i.Value is DbLogger).Value.Log("hello world");
        }
    }

咋一看并没有什么问题，所有的Logger都是延迟创建的。但是仔细分析一下就会发现，要找到DbLogger的时候，必须遍历所有的_loggerServices，这个遍历会导致创建Logger。也就是说，使用第一个Logger的时候可能创建所有的Logger。

那么，如何实现我们只创建所需要的Logger呢？ 这个时候就轮到元数据出场了，MEF中的元数据可以将一个数据附加到Export的服务对象中一并导出，从而可以通过元素据找到对应的服务。首先我们看看最终的效果吧：

    public interface ILoggerData
    {
        string Name { get; }
    }

    class Host
    {
        [ImportMany]
        Lazy<ILogger, ILoggerData>[] _logger = null;

        public Host()
        {
            var catalog = new AssemblyCatalog(this.GetType().Assembly);
            var container = new CompositionContainer(catalog);

            container.ComposeParts(this);

            _logger.FirstOrDefault(i => i.Metadata.Name == "DB Logger").Value.Log("hello world");
        }
    }

这里首先声明了一个元数据类型的接口ILoggerData，然后，导入的对象变成了Lazy<ILogger, ILoggerData>，这个对象有一个属性为Metadata，它的类型就是刚才声明的ILoggerData。导出的ILogger对象是延迟创建的，而元数据不是延迟创建的。我们可以通过遍历ILoggerData来找到所需要的Logger对象，从而实现只创建所使用的Logger对象。

现在的问题是：如何在导出的时候声明相关的元数据。MEF提供了两种方式：

通过ExportMetadataAttribute标记声明

这种方式是在导出的服务的时候一并通过ExportMetaDataAttribute属性标记元素据：

    [ExportMetadata("Name", "Console Logger")]
    [Export(typeof(ILogger))]
    class ConsoleLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine(message);
        }
    }

    [ExportMetadata("Name", "DB Logger")]
    [Export(typeof(ILogger))]
    class DbLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine(message);
        }
    }

ExportMetaDataAttribute有两个参数，Name和Value，Name为属性名称，Value为属性值。Compse的时候，MEF会先创建一个实现了元数据对象，然后将根据将Value值赋值给Name所对应的属性名称。

这么做虽然比较简单，但是它有两个弊端：

  • 1. 属性名称不是强类型

这里我们必须字符串来给标志属性名称，它们之间并没有语法级的一致性检查，在缺少nameof运算符的现在，一旦元数据属性名称更改的话是非常容易出错的。

  • 2. 如果元数据有多个值的话赋值显得非常累赘。

假如我们增加了一个Priority类型的属性，

    public interface ILoggerData
    {
        string Name { get; }
        int Priority { get; }
    }

此时，必须对所有的导出对象都增加一个ExportMetadata标记，写出如下形式：

    [ExportMetadata("Name", "DB Logger")]
    [ExportMetadata("Priority", 3)]

当属性更多一点的话相信程序员们就会骂娘了。并且一旦某个Export对象漏写了，改对象就不会被导入。这个是一个运行时的错误，非常不容易排查的。

通过Attribute标记

这种方式可以通过一个Attribute来标记元数据：

    [MetadataAttribute]
    [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
    class LoggerDataAttribute : Attribute, ILoggerData
    {
        public string Name { get; private set; }

        public LoggerDataAttribute(string name)
        {
            this.Name = name;
        }
    }

    [LoggerData("Console Logger")]
    [Export(typeof(ILogger))]
    class ConsoleLogger : ILogger, ILoggerData
    {
        public string Name { get; set; }

        public void Log(string message)
        {
            Console.WriteLine(message);
        }
    }

    [LoggerData("DB Logger")]
    [Export(typeof(ILogger))]
    class DbLogger : ILogger, ILoggerData
    {
        public string Name { get; set; }
        public void Log(string message)
        {
            Console.WriteLine(message);
        }
    }

首先，声明一个LoggerDataAttribute，这个Attribute必须被MetadataAttribute标记。然后，在Export的对象前加上该LoggerDataAttribute，这样MEF导入的时候就会根据该LoggerDataAttribute创建元数据了。

值得一提的是，这里的LoggerDataAttribute本身并不需要实现ILoggerData接口，它是一个DuckType的约定，只需要实现元数据的属性即可。我这里实现该接口主要是为了让编译器保障元数据属性都有被准确实现。

到此这篇关于C#在MEF框架中实现延迟加载部件的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持编程网。

--结束END--

本文标题: C#在MEF框架中实现延迟加载部件

本文链接: https://lsjlt.com/news/152392.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作