白话系列之IOC,三个类实现简单的Ioc

  • 2019 年 10 月 3 日
  • 筆記

前言:博客园上已经有很多IOC的博客.而且很多写的很好,达到开源的水平,但是对于很多新人来说,只了解ioc的概念,以及怎么去使用ioc.然后想更进一步去看源码,但是大部分源码都比较困难,当不知道一个框架整体时候,从每一个片段去推理,其实很耗费时间,所以这篇博客,从autofac及.netcore自带的ioc的源码中抽象出最核心代码,先了解整个ioc的实现方式,其他的所有好的ioc,只是在这个框架上面进行缝缝补补.

友情提示下,这个ioc虽然能够使用,但是只是为了做例子,所以只保留最核心代码,要使用还是使用autofac或成熟的ioc框架.

一:老生常谈

问:什么是ioc?

答:依赖注入,是一种思想,由于过分模糊,所以提出DI的观点:被注入对象依赖IOC容器配置依赖对象

问:有什么用?

答:解决高耦合问题,以前没有ioc的时候,每次都执行的是new操作,这没什么不好,但是假设,本来使用sqlserver,通过IConnection  conn = new Sqlserver();方式初始化所有的连接操作,但是现在老板要求改成mysql当做数据库,如果按照new的方式,得一个个去改,全局搜索,全局替换,其实也是可以的,无非是人累点,还需要一遍遍去检查,看哪里漏了,这时候就怀念Ioc的好处了,只需在容器内改变一处,便全局改变.当然,这里并不是少写了几行new代码,代码还是一样的多,只不过new的操作让容器去处理了.拟人化的方式就是,new的方式就相当于以前没群的时候,你本来是密令是10, 你一个个去通知你所想要通知的人即new,但是现在呢,密令被敌人偷听去了,你需要更改,这次改成20,你就得一个个通知,但是现在你每次联系别人都是通过手机去联系,你不需要管手机是怎么发送给对方的,只需要知道你给手机一个通知,其他人都可以立马收到,那么手机在这里扮演的就是容器的概念,一次更改,全部获悉

二:理论结束,开始思考准备ioc之前需要准备的东西

1.首先建立一个收集器,收集可能需要new的对象,那么会有几种生命周期去new一个对象?

常用的就是单例模式(singleton), 每次直接new对象,即用即抛(Transient),还有当前请求的主线程中只会创建一个对象(Scope,注意,单例是所有请求都会公用一个对象),所以,先定义接口,如下,命名即功能

    public interface IServiceCollection      {          IServiceCollection AddTransient<T1, T2>() where T2 : T1;          IServiceCollection AddTransient<T1>(T1 t2);          IServiceCollection AddSingleton<T1, T2>() where T2 : T1;          IServiceCollection AddSingleton<T1>(T1 t2);          IServiceCollection AddScoped<T1, T2>() where T2 : T1;          IServiceCollection AddScoped<T1>(T1 t2);          IServiceProvider BuildServiceProvider();      }

 2.其次,建立一个对象提供器,获取容器内的可以获取的对象

    越简单越好,直接通过类型获取对应的对象,同样,接口定义如下:

    public interface IServiceProvider      {          T GetRequiredService<T>();          Object GetRequiredService(Type type);      }

3.Collection对收集的对象进行保存,并且需要对每个对象进行区分是Singleton,scoped,还是transient的

注意:我觉得在设计一个好的代码时候,得弄清楚当前类型具体的作用,然后如果作用不一样,那么得重新创建一个类型,当然如果后期发现没必要,可以合并,但是前期还是得分清楚点,就如sql中的范式及反范式.

 3.1:首先定义枚举,区分当前的类型需要new的类型,与上文中的一致

 

    public enum ServiceLifetime      {          Singleton = 0,          Transient = 1,          Scoped = 2      }

 

  3.2:其次需要保存注入进去的类型及周期,因为不去考虑架构,只考虑那ioc的意思,就尽量简化代码

 

三:直接开始撸代码

 

1.通过Type创建对象,先默认只创建当前无参构造器,代码很简单

 

        public Object GetCache(IDictionary<Type, IServiceCache> typePairs)          {              if (_obj == null)              {                  _obj = Activator.CreateInstance(_type);              }              switch (_typeEnum)              {                  case ServiceLifetime.Transient:                      return Activator.CreateInstance(_type);                  case ServiceLifetime.Singleton:                      return _obj;                  case ServiceLifetime.Scoped:                      throw new Exception("目前不支持scoped");                  default:                      throw new Exception("请传递正确生命周期");              }          }

 

 

 

DeepClone的写法就是通过序列化的方式实现的,JsonConvert

      public static Object DeepClone(this Object obj, Type type)          {              return JsonConvert.DeserializeObject(JsonConvert.SerializeObject(obj), type);          }

2.collection保存对应的对象,继承IServiceCollection接口

 

    public class ServiceCollection : IServiceCollection      {          private ConcurrentDictionary<Type, IServiceCache> _typePairs;          public ServiceCollection()          {              _typePairs = new ConcurrentDictionary<Type, IServiceCache>();          }          public IServiceCollection AddScoped<T1, T2>() where T2 : T1{}          public IServiceCollection AddScoped<T1>(T1 t2){}          public IServiceCollection AddSingleton<T1, T2>() where T2 : T1{}          public IServiceCollection AddTransient<T1, T2>() where T2 : T1{}          public IServiceCollection AddSingleton<T>(T t2){}          public IServiceProvider BuildServiceProvider(){}      }

 实现Singleton及Transient,此处Scoped有些额外的语法糖,等后期会猜想实现

       public IServiceCollection AddSingleton<T1, T2>() where T2 : T1          {              Type t1 = typeof(T1);              Type t2 = typeof(T2);              ServiceTypeCache service = new ServiceTypeCache(t2, ServiceLifetime.Singleton);              if (!_typePairs.TryAdd(t1, service))              {                  throw new Exception("在注入对象时,有相同对象存在");              }              return this;          }          public IServiceCollection AddTransient<T1, T2>() where T2 : T1          {              Type t1 = typeof(T1);              Type t2 = typeof(T2);              ServiceTypeCache service = new ServiceTypeCache(t2, ServiceLifetime.Transient);              if (!_typePairs.TryAdd(t1, service))              {                  throw new Exception("在注入对象时,有相同对象存在");              }              return this;          }

 3:实现IServiceProvider接口,就是从Cache中获取对应的对象

    public class ServiceProvider : IServiceProvider      {          private IDictionary<Type, IServiceCache> _cache;          public ServiceProvider(IDictionary<Type, IServiceCache> valuePairs)          {              _cache = valuePairs;          }          public T GetRequiredService<T>()          {              Type t = typeof(T);              return (T)GetRequiredService(t);          }          public object GetRequiredService(Type type)          {              IServiceCache service = null;              if (!_cache.TryGetValue(type, out service))              {                  throw new Exception("获取参数对象没有注入");              }              return service.GetCache();          }      }

 

 4:将Collection转变为ServiceProvider

        public IServiceProvider BuildServiceProvider()          {              return new ServiceProvider(_typePairs);          }

5:OK,现在来试试这种简单注入

    public interface ITestTransient      {          void Write();      }      public class TestATransient : ITestTransient      {          public void Write()          {              Console.WriteLine("----------------A----------------");          }      }      public class TestBTransient : ITestTransient      {          public void Write()          {              Console.WriteLine("----------------B----------------");          }      }

 

class Program      {          static void Main(string[] args)          {              InitA();              InitB();              Console.Read();          }          public static void InitA()          {              IServiceCollection collection = new ServiceCollection();              collection.AddTransient<ITestTransient, TestATransient>();              IServiceProvider provider =  collection.BuildServiceProvider();              provider.GetRequiredService<ITestTransient>().Write();          }          public static void InitB()          {              IServiceCollection collection = new ServiceCollection();              collection.AddTransient<ITestTransient, TestBTransient>();              IServiceProvider provider = collection.BuildServiceProvider();              provider.GetRequiredService<ITestTransient>().Write();          }      }

 

测试OK,只要在后面的代码中使用同一个provider,那么从IOC容器中获取的实例都是相同,改一处便全部都能修改

6.延伸,现在通过构造器注入其他代码,比如 

class A{}  class B  {     public B(A a) { }  }

猜想下,遇到这种构造器注入时候,怎么去处理,其实和创建Type对象一直,通过CreateInstance(Type, Object[] param);去创建,param是每个需要注入的类型对象

OK,那我们来改下代码,将获取Object对象的方法添加参数,因为构造器里面注入的参数都是从IOC里面获取

    public interface IServiceCache      {          Object GetCache(IDictionary<Type, IServiceCache> typePairs);      }

获取当前Type类型的构造器,默认获取参数最多的,参数一样多的,获取最后一个,注:这里可以添加一个特性,标明优先构造这个构造器,自己添加就好,写法尽量简单

        private List<Type> GetConstructor()          {              ConstructorInfo[] a = _type.GetConstructors();              ConstructorInfo b = null;              Int32 length = 0;              foreach (ConstructorInfo info in a)              {                  if (info.GetParameters().Length >= length)                  {                      b = info;                  }              }              ParameterInfo[] pa = b.GetParameters();              List<Type> list = new List<Type>();              foreach (var p in pa)              {                  list.Add(p.ParameterType);              }              return list;          }

构造器参数,就需要从typePairs里面获取,注意,这里的所有参数都必须从IOC容器中获取,当然这里会有一个问题就是相互引用,这时候就需要注意下

        public Object GetCache(IDictionary<Type, IServiceCache> typePairs)          {              if (_obj == null)              {
          //这里实际是构建一个表达式树,这样就不需要每次去通过反射创建对象了 List
<Type> types = GetConstructor(); Object[] paramters = types.ConvertAll(item => typePairs[item].GetCache(typePairs)).ToArray(); _obj = Activator.CreateInstance(_type, paramters); } switch (_typeEnum){...} }

7.测试

    public class ConstructorIOCTest      {          private readonly ITestTransient m_test;          public ConstructorIOCTest(ITestTransient test)          {              m_test = test;          }          public void WriteTestTransient()          {              m_test.Write();              Console.WriteLine("--------------ConstructorIOCTest-----------");          }      }

    class Program      {          static void Main(string[] args)          {              InitA();              InitB();              Console.Read();          }          public static void InitA()          {              IServiceCollection collection = new ServiceCollection();              collection.AddTransient<ITestTransient, TestATransient>();              collection.AddTransient<ConstructorIOCTest, ConstructorIOCTest>();              IServiceProvider provider =  collection.BuildServiceProvider();              provider.GetRequiredService<ConstructorIOCTest>().WriteTestTransient();          }          public static void InitB()          {              IServiceCollection collection = new ServiceCollection();              collection.AddTransient<ITestTransient, TestBTransient>();              collection.AddTransient<ConstructorIOCTest, ConstructorIOCTest>();              IServiceProvider provider = collection.BuildServiceProvider();              provider.GetRequiredService<ConstructorIOCTest>().WriteTestTransient();          }      }

 

 可以看出来,所有的IOC都是从构造器出发,这样就避免到处修改的尴尬了

总结:

1.这是一个简单的IOC代码,里面我尽量采用最简单的小白的方式去实现,没有使用设计模式(本身最多有个工厂模式),没有表达式树,没有锁(锁是非常重要的,后期我会花几个章节去介绍各种锁)

2.IOC其实就是一个概念,理解之后,在构造的时候添加几个特性,比如属性注入,方法注入,其实无非就是在ServiceTypeCache类中添加构造器,方法,属性筛选之类的语法糖而已

3.这里没有时间Scopd的生命周期,因为我并不是很确定.net core中这个的写法,对我来说有2种,一种是在GetService时候,HttpContext注入,一种是将ServiceProvider里面进行包装一层Guid,相同的Guid的Scopd相同

4.希望大家可以去看看源码,尤其是推荐微软开源的几个框架,代码之精华,越看越觉得代码之美,虽然里面很多代码就是在打补丁,坑死人

5.https://github.com/BestHYC/IOCSolution.git,源码,代码的话我就不加工了,因为没什么好加工的,毕竟IOC实在太成熟了