.NET6.0实现IOC容器

IOC 的作用这里省略…只对如何使用进行说明.

1. 创建一个.NET6应用程序

这里使用 .NET6.0 WebAPI 应用 。

2. 声明接口

                        
                            public interface IAuthService
  {
        bool CheckToken();
  }

                        
                      

3. 实现接口

                        
                          class AuthServiceImpl : IAuthService
{
        public bool CheckToken()
        {
            Console.WriteLine("check token");
            return true;
        }
}

                        
                      

4. 配置IOC容器

下面是在 program 类中的代码 。

                        
                          var services = new ServiceCollection();
services.AddSingleton<IAuthService, AuthServiceImpl>();

                        
                      

5. 获取服务

通过在 Controller 的构造函数中注入 IAuthService 。

                        
                          		private readonly IAuthService _service;  
		public WeatherForecastController(IAuthService service)
        {
            _service = service;
        }

        [HttpGet(Name = "test")]
        public bool Get()
        {
           return _service.CheckToken();
        }

                        
                      

启动后，通过 swagger 发起请求，验证接口.

基本 IOC容器 流程已实现。但是这样存在一个弊端，每个接口和实现都要在 program 中手动注册一遍，还要在 Controller 构造函数中进行依赖注入，有没有能自动实现注册代替 program 中的手动注册?

接下来，对上述流程进行改良.

6. 改良思路

定义一个 AutowiredAttribute 标记，通过 Atrribute 标记的方式，在实现类上标记其要实现的接口服务，然后实现一个服务加载类 ServiceLoader ，在这个类中反射获取所有具备 AutoIocAttribute 的实现类，然后注册到 ServiceCollection 中.

6.1 定义特性标记AutowiredAttribute

                        
                              [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
    public class AutowiredAttribute : Attribute
    {
        /// <summary>
        /// 接口
        /// </summary>
        public Type Iface { get; set; }
        /// <summary>
        /// 实现类名
        /// </summary>
        public string ImplClassName { get; set; }

        public AutowiredAttribute(Type iface, [CallerMemberName] string implClassName = "")
        {
            Iface = iface;
            ImplClassName = implClassName;
        }
    }

                        
                      

6.2 实现服务加载类

利用 IServiceCollection 作为服务容器 。

                        
                              public class ServiceLoader
    {
        private static object _lock = new object();
        private static AppRuntime _inst;
        private readonly IServiceCollection _iocService = new ServiceCollection();
        private readonly ICollection<Assembly> _iocAssembly = new HashSet<Assembly>();
        private IServiceProvider _iocServiceProvider = null;


        public static ServiceLoader Instance
        {
            get
            {
                if (_inst == null)
                {
                    lock (_lock)
                    {
                        _inst = new ServiceLoader();
                        _inst.Startup(typeof(ServiceLoader).Assembly);
                    }
                }
                return _inst;
            }
        }

        public T GetService<T>()
        {
            EnsureAutoIoc<T>();
            return _iocServiceProvider.GetService<T>();
        }

        private void EnsureAutoIoc<T>()
        {
            Startup(typeof(T).Assembly);
        }

        public void Startup(Assembly ass)
        {
            if (_iocAssembly.Any(x => x == ass))
            {
                return;
            }
            _iocAssembly.Add(ass);

            var types = ass.GetTypes().Where(x => x.GetCustomAttribute<AutowiredAttribute>() != null);
            foreach (var item in types)
            {
                var autoIocAtt = item.GetCustomAttribute<AutowiredAttribute>();
                AddTransient(autoIocAtt.Iface, item);
            }
            //_iocServiceProvider = _iocService.BuildServiceProvider();
            Interlocked.Exchange(ref _iocServiceProvider, _iocService.BuildServiceProvider());
        }

        private void AddTransient(Type iface, Type impl)
        {
            _iocService.AddTransient(iface, impl);
        }
    }

                        
                      

6.3 在实现类加上标记

                        
                              [Autowired(typeof(IAuthService))]
    class AuthServiceImpl : IAuthService
    {
    
        public bool CheckToken()
        {
            Console.WriteLine("check token");
            return true;
        }
    }

                        
                      

6.4 在 Controller 中调用

                        
                             var svc = ServiceLoader.Instance.GetService<IAuthService>();
   svc.CheckToken();

                        
                      

至此一个基本的完整 IOC容器 已实现.

最后此篇关于.NET6.0实现IOC容器的文章就讲到这里了,如果你想了解更多关于.NET6.0实现IOC容器的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。