一天两天三天
https://www.cnblogs.com/santian/p/4357324.html
随笔 - 51,  文章 - 0,  评论 - 65,  阅读 - 20万

文章参考:在MEF中实现延迟加载部件  作者:TianFang

 仅有一个服务提供者时候

复制代码
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;

namespace 延迟加载
{
    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]
        //延迟加载
        Lazy<ILogger> _logger;
        //非延迟加载
        //ILogger _logger;
        public Host()
        {
            var catalog = new AssemblyCatalog(this.GetType().Assembly);
            var container = new CompositionContainer(catalog);

            //如果不是延迟加载的话这儿会创建ConsoleLogger对象
            container.ComposeParts(this);
            //非延迟加载
            //_logger.Log("logworld");
            //延迟加载
            _logger.Value.Log("hello world");

        }
    }
}
View Code
复制代码

 

 当某一组件并不是立刻需要使用,或者内存开销很大。影响程序加载的速度。比如当程序启动的时候。这个时候我们可以使用延迟加载,也就是只有当程序用到的时候才会去加载该部件。我们可以使用Lazy<T>来标记导入的类型。这样就简单的实现了延迟加载。

注意如果使用Lazy<T>来标记对象类型的话,需要通该实例的Value属性调用实例方法 _logger.Value.Log("hello world");

如果是非延迟加载

如果延迟加载:

 

当有多个服务提供者的时候

复制代码
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.Linq;
namespace 延迟加载
{
    interface ILogger
    {
        void Log(string message);
    }
    [Export(typeof(ILogger))]
    class ConsoleLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine("ConsoleLogger    " + message);
        }
    }

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

    class Host
    {   //非延迟加载
        //[ImportMany]
        //ILogger[] _logger = null;
        //延迟加载
        [ImportMany]
        Lazy<ILogger>[] _Lazylogger = 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");
            //延迟加载,当调用的时候才创建对象,
            //但是因为这儿有一个遍历,所以当调用一个对象的时候就会创建所以对象
            _Lazylogger.FirstOrDefault(i => i.Value is DbLogger).Value.Log("DbLogger");
        }
    }
}
View Code
复制代码

 

此时可以用ImportMany标记导入,同时用Lazy<T>包装我们的导入类型。但是此时有个问题,就是当我们如果通过类型遍历多个对象寻找可用导入时候,会创建所有对象。所以此时我们可以用元数据来判断是否使我们需要的导入。

通过元数据匹配需要的导入

复制代码
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.Linq;
namespace 延迟加载
{
    interface ILogger
    {
        void Log(string message);
    }
    //通过标记元数据来标记导出服务
    [ExportMetadata("Name", "Console Logger")]
    [Export(typeof(ILogger))]
    class ConsoleLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine("ConsoleLogger    " + message);
        }
    }
    //通过标记元数据来标记导出服务
    [ExportMetadata("Name", "DbLogger")]
    [Export(typeof(ILogger))]
    class DbLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine("DbLogger    " + message);
        }
    }
    public interface ILoggerData
    {
        string Name { get; }
    }
    class Host
    {
        //延迟加载
        [ImportMany]
        Lazy<ILogger,ILoggerData>[] _Lazylogger = null;
        public Host()
        {
            var catalog = new AssemblyCatalog(this.GetType().Assembly);
            var container = new CompositionContainer(catalog);
            //非延迟加载此时会创建所有对象
            container.ComposeParts(this);
            //延迟加载,当调用的时候才创建对象,
            //但是因为这儿有一个遍历,所以当调用一个对象的时候就会创建所以对象
            //_Lazylogger.FirstOrDefault(i => i.Value is DbLogger).Value.Log("DbLogger");
            _Lazylogger.FirstOrDefault(i => i.Metadata.Name == "DbLogger").Value.Log("DbLogger");

        }
    }
}
View Code
复制代码

通过元数据可以匹配我们需要的导出服务。但是,通过单纯的标记  [ExportMetadata("Name", "DbLogger")]很麻烦,而且属性笔记多的时候代码也不整洁。对此我们可以封装一个元数据特性

   

复制代码
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.Linq;
namespace 延迟加载
{
    interface ILogger
    {
        void Log(string message);
    }
    //通过标记元数据来标记导出服务
     [LoggerData("Console Logger")]
    [Export(typeof(ILogger))]
    class ConsoleLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine("ConsoleLogger    " + message);
        }
    }
    //通过标记元数据来标记导出服务
    [LoggerData("DbLogger")]
    [Export(typeof(ILogger))]
    class DbLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine("DbLogger    " + message);
        }
    }
    public interface ILoggerData
    {
        string Name { get; }
    }
    [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;
        }
    }
    class Host
    {
        //延迟加载
        [ImportMany]
        Lazy<ILogger, ILoggerData>[] _Lazylogger = null;
        public Host()
        {
            var catalog = new AssemblyCatalog(this.GetType().Assembly);
            var container = new CompositionContainer(catalog);
            //非延迟加载此时会创建所有对象
            container.ComposeParts(this);
            //延迟加载,当调用的时候才创建对象,
            //但是因为这儿有一个遍历,所以当调用一个对象的时候就会创建所以对象
            //_Lazylogger.FirstOrDefault(i => i.Value is DbLogger).Value.Log("DbLogger");
            _Lazylogger.FirstOrDefault(i => i.Metadata.Name == "DbLogger").Value.Log("DbLogger");

        }
    }
}
复制代码

 

本文地址:http://www.cnblogs.com/santian/p/4357324.html

博客地址:http://www.cnblogs.com/santian/

转载请以超链接形式标明文章原始出处。
posted on   一天两天三天  阅读(1472)  评论(5编辑  收藏  举报
编辑推荐:
· Linux系列:如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列(二):开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
· 理解Rust引用及其生命周期标识(上)
阅读排行:
· 阿里最新开源QwQ-32B,效果媲美deepseek-r1满血版,部署成本又又又降低了!
· 单线程的Redis速度为什么快?
· SQL Server 2025 AI相关能力初探
· 展开说说关于C#中ORM框架的用法!
· AI编程工具终极对决:字节Trae VS Cursor,谁才是开发者新宠?

< 2025年3月 >
23 24 25 26 27 28 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 1 2 3 4 5
点击右上角即可分享
微信分享提示