欢迎光临
我的个人博客网站

手写IOC实践


一、IOC

1.什么是IOC?

控制反转(英语:Inversion of Control,缩写为IoC),是[面向对象编程]中的一种设计原则,可以用来减低计算机代码之间的[耦合度]其中最常见的方式叫做依赖注入(Dependency Injection,简称DI),还有一种方式叫“依赖查找”(Dependency Lookup).

IoC:是一种设计模式

DI:是践行控制反转思想的一种方式

2.为什么要用IOC

因为IoC 控制反转是依赖抽象,而抽象是稳定的,不依赖细节,因为细节还可能会依赖其他细节,为了屏蔽细节,需要使用依赖注入去解决无限层级的对象依赖。

3.Net中常用的IoC容器

目前用的最多的是AutoFac和Castle,在.Net Core中框架内置了IOC容器,Unity和ObjectBuilder是相对比较久远的框架,用的比较少。

  1. AutoFac

  2. Castle

  3. Unity

  4. ObjectBuilder

二、如何手写实现?

1.基本设计

核心思想: 工厂 + 反射

首先我们想自己实现一个IoC容器其实并不难,我们在使用现有的IoC容器都知道,在使用前,我们需要先注册,然后才能使用

所以我们将工厂换成手动注册的方式,因为写一大堆if else 或者switch也不太美观,根据主流IoC的使用方式来以葫芦画瓢,如果后期继续完善功能加入程序集注入的话,还是得实现一个工厂,来省略手动注册

但是这次目标是实现一个简易版的IoC容器,我们先实现基础功能,待后面一步一步去完善,再加入一些新的功能,即我们不考虑性能或者扩展度,目的是循序渐进,在写之前我们先整理出 实现步骤和实现方式

  1. 方便接入和扩展,我们在这先定义一个容器接口 IManualContainer

  2. 定义ManualContainer继承实现IManualContainer

  3. 声明一个静态字典对象存储注册的对象

  4. 利用反射构建对象,考虑到性能可以加入Expression或者Emit的方式来做一些优化

classDiagram IManualContainer <|– ManualContainer IManualContainer: +Register<TFrom, To>() IManualContainer: +Resolve<Tinterface>() class ManualContainer{ -Dictionary<string, Type> container +Register() +Resolve() -CreateInstance() }
public interface IManualContainer {       void Register<TFrom, To>(string servicesName = null) where To : TFrom;        Tinterface Resolve<Tinterface>(string servicesName = null); } 
2.要实现的功能

1.基本对象构造

2.构造函数注入

3.多级依赖和多构造函数及自定义注入

4.属性注入&方法注入

5.单接口多实现

三、编码实现及思路剖析

1.实现构造对象(单接口注入)

1.首先实现接口来进行编码私有字段 container用来存储注册的类型,key是对应接口的完整名称,Value是需要Resolve的类型。

2.泛型约束保证需要被Resolve类型 (To) 实现或者继承自注册类型 (TFrom)

public class ManualContainer : IManualContainer {    //存储注册类型    private static Dictionary<string, Type> container =     new Dictionary<string, Type>();        //注册     public void Register<TFrom, To>(string servicesName = null) where To : TFrom     {         string Key = $"{typeof(TFrom).FullName}{servicesName}";         if (!container.ContainsKey(Key))         {             container.Add(Key, typeof(To));         }     } 

1.实现构造对象,首先需要传入被构造的类型的抽象接口T

2.在Resolve中根据T作为Key,在存储容器中找到注册时映射的类型,并通过反射构造对象

   //构建对象    public TFrom Resolve<TFrom>(string servicesName = null)    {        string Key = $"{typeof(TFrom).FullName}{servicesName}";        container.TryGetValue(key, out Type target);        if(target is null)        {            return default(TFrom);        }        object t = Activator.CreateInstance(target);    } } 

1.首先我们准备需要的接口(ITestA)和实例(TestA)来利用容器来构造对象

public interface ITestA {     void Run(); } public class TestA : ITestA {    public void Run()=> Console.WriteLine("这是接口ITestA的实现"); } 

2.调用IoC容器来创建对象

IManualContainer container = new ManualContainer(); //注册到容器中 container.Register<ITestA, TestA>(); ITestA instance = container.Resolve<ITestA>(); instance.Run(); //out put "这是接口ITestA的实现" 
2.构造函数注入

1.假设我们的TestA类中需要ITestB接口的实例或者其他更多类型的实例,并且需要通过构造函数注入,我们应该如何去完善我们的IoC容器呢?

public class TestA : ITestA {     private ITestB testB = null;    //构造函数    public TestA(ITestB testB)=> this.testB = testB;        public void Run()    {       this.testB.Run();       Console.WriteLine("这是接口ITestA的实现");    } } 

2.我们按照上面的步骤照常注册和构造对象,发现报错了,在Resolve()的时候,经过调试知道是使用反射构造的时候报错了,因为在构造TestA缺少构造参数,那么我们就需要在反射构造时加入参数。

  1. 先定义List<object>集合存储对象构造时需要的参数列表

  2. 通过需要被实例的目标类型找到类中的构造函数,暂不考虑多构造函数case

  3. 找到构造函数参数及类型,然后创建参数的实例加入List中,在反射构造时传入参数就解决了

   //完善Resolve构建对象函数    public TFrom Resolve<TFrom>(string servicesName = null)    {        string Key = $"{typeof(TFrom).FullName}{servicesName}";        container.TryGetValue(key, out Type target);        if(target is null)        {            return default(TFrom);        }                //存储参数列表        List<object> paramList = new List<object>();        //找到目标类型的构造函数,暂不考虑多构造函数case        var ctor = target.GetConstructors().FirstOrDefault();        //找到参数列表        var ctorParams = ctor.GetParameters();        foreach (var item in ctorParams)        {            //参数类型            Type paramType = item.ParameterType;            string paramKey = paramType.FullName;            //找到参数注册时映射的实例            container.TryGetValue(paramKey, out Type ParamType);            //构造出实例然后加入参数列表            paramList.Add(Activator.CreateInstance(ParamType));        }             object t = Activator.CreateInstance(target,paramList);    } } 
3.多级依赖(递归)

根据上面我们目前实现的结果来看,这是解决了构造函数和多参数注入以及基本的构造对象问题,那现在问题又来了

  1. 如果是很多层的依赖该怎么办?

  2. 例如多个构造函数怎么办呢?

  3. 在多个构造函数中用户想自定义需要被注入的构造函数怎么办?

总结3点问题

  • 1.多级依赖问题

例如ITestB 的实例中依赖ITestC,一直无限依赖我们怎么解决呢?毫无疑问,做同样的事情,但是要无限做下去,就使用 递归,下面我们来改造我们的方法

  • 2.多个构造函数

    1. 取参数最多的方式注入 (AutoFac)

    2. 取并集方式注入 (ASP .NET Core)

  • 3.自定义注入

    我们可以使用特性标记的方式来实现,用户在需要被选择注入的构造函数上加入特性标签来完成


1.创建私有递归方法,这个方法的作用就是创建对象用

private object CreateInstance(Type type,string serviceName = null) { } 

2.我们选择第一种方式实现,修改之前获取第一个构造函数的代码,选择最多参数注入

 //找到目标类型的构造函数,找参数最多的构造函数   ConstructorInfo ctor = null;   var ctors = target.GetConstructors();   ctor = ctors.OrderByDescending(x => x.GetParameters().Length).First(); 

3.自定义特性CtorInjection,可以使用户自定义选择

 //自定义构造函数注入标记  [AttributeUsage(AttributeTargets.Constructor)]  public class CtorInjectionAttribute : Attribute  {  } 

4.最终代码

private object CreateInstance(Type type,string serviceName = null) {    string key = $"{ type.FullName }{serviceName}";    container.TryGetValue(key, out Type target);    //存储参数列表    List<object> paramList = new List<object>();       ConstructorInfo ctor = null;    //找到被特性标记的构造函数作为注入目标    ctor = target.GetConstructors().FirstOrDefault(x => x.IsDefined(typeof(CtorInjectionAttribute), true));     //如果没有被特性标记,那就取构造函数参数最多的作为注入目标    if (ctor is null)    {       ctor = target.GetConstructors().OrderByDescending(x => x.GetParameters().Length).First();    }    //找到参数列表    var ctorParams = ctor.GetParameters();    foreach (var item in ctorParams)    {        //参数类型        Type paramType = item.ParameterType;        //递归调用构建对象        object paramInstance = CreateInstance(paramType);        //构造出实例然后加入参数列表        paramList.Add(paramInstance);    }        object t = Activator.CreateInstance(target);    return t; }   public TFrom Resolve<TFrom>()   {     return (TFrom)this.CreateInstance(typeof(TFrom));  } 
4.属性注入&方法注入

1.自定义特性PropInjection,可以使用户自定义选择

 //自定义构造属性注入标记  [AttributeUsage(AttributeTargets.Property)]  public class PropInjectionAttribute : Attribute  {  }   //自定义构造方法注入标记  [AttributeUsage(AttributeTargets.Method)]  public class MethodInjectionAttribute : Attribute  {  } 

2.遍历实例中被标记特性的属性。

3.获取属性的类型,调用递归构造对象函数。

4.设置目标对象的属性值。

5.方法注入也是同理,换汤不换药而已

private object CreateInstance(Type type,string serviceName = null) {   string key = $"{ type.FullName }{serviceName}";    container.TryGetValue(key, out Type target);    //存储参数列表    List<object> paramList = new List<object>();       ConstructorInfo ctor = null;    //找到被特性标记的构造函数作为注入目标    ctor = target.GetConstructors().FirstOrDefault(x => x.IsDefined(typeof(CtorInjectionAttribute), true));     //如果没有被特性标记,那就取构造函数参数最多的作为注入目标    if (ctor is null)    {       ctor = target.GetConstructors().OrderByDescending(x => x.GetParameters().Length).First();    }    //找到参数列表    var ctorParams = ctor.GetParameters();    foreach (var item in ctorParams)    {        //参数类型        Type paramType = item.ParameterType;        //递归调用构建对象        object paramInstance = CreateInstance(paramType);        //构造出实例然后加入参数列表        paramList.Add(paramInstance);    }        object t = Activator.CreateInstance(target);        //获取目标类型的被特性标记的属性<属性注入>    var propetys = target.GetProperties().Where(x => x.IsDefined(typeof(PropInjectionAttribute), true));    foreach (var item in propetys)     {        //获取属性类型        Type propType = item.PropertyType;        object obj = this.CreateInstance(propType);        //设置值        item.SetValue(t, obj);    }        //获取目标类型的被特性标记的方法<方法注入>    var methods = target.GetMethods().Where(x => x.IsDefined(typeof(MethodInjectionAttribute), true)).ToList();    foreach (var item in methods)     {         List<object> methodParams = new List<object>();         foreach (var p in item.GetParameters())         {              //获取方法参数类型             Type propType = p.ParameterType;             object obj = this.CreateInstance(propType);             methodParams.Add(obj);         }         item.Invoke(t, methodParams);     }    return t; }   public TFrom Resolve<TFrom>()   {     return (TFrom)this.CreateInstance(typeof(TFrom));  } 
5.单接口多实现

假设我们一个接口被多个实例实现,我们需要注入怎么操作呢?

毫无疑问我们应该想到在注入时取一个别名,没错正是这种方法,但是也会存在一个问题,我们取了别名之后只能解决注入的场景?那依赖接口的地方如何知道注入哪一个实例呢?

1.注册单接口多实例

container.Register<ITest, test1>("test1"); container.Register<ITest, test2>("test2"); ITest instance = container.Resolve<ITest>("test1"); ITest instance1 = container.Resolve<ITest>("test2"); 

2.创建标记特性,用来标记目标对象

[AttributeUsage(AttributeTargets.Parameter| AttributeTargets.Property)] public class ParamterInjectAttribute : Attribute {    public ParamterInjectAttribute(string nickName) => NickName = nickName;    public string NickName { get; private set; } } 

3.我们需要在依赖“单接口多实例的类中”使用时告诉参数,我们需要的实例,依然使用参数特性标记

public class use : IUse {     private ITest _Test = null;     //告诉构造函数依赖ITest接口时使用别名为test1的实例     public BLL1([ParamterInjectAttribute("test1")] ITest接口时使用别名为test1的实例 Test)     {         this._Test = Test;     } } 

4.在构造对象时查找是否被特性标记,然后构造对象

foreach (var item in ctor.GetParameters()) {     Type paramType = item.ParameterType;     string nickName = string.Empty;     //查找构造函数的参数是否被特性标记     if (item.IsDefined(typeof(ParamterInjectAttribute), true))     {     //找到被标记需要构造的实例别名         nickName = item.GetCustomAttribute<ParamterInjectAttribute>().NickName;     }     //根据别名创建对象     object instance = CreateInstance(paramType,nickName);     if (instance != null)     {         paramList.Add(instance);     }  } 

四、总结

目前还不是很完善,只是实现了属性,方法,以及构造函数注入,很多必要功能还没有,下一步将在现有代码基础上利用Emit的方式来创建对象,加入基本的验证环节以提高健壮性,加入生命周期管理,和AOP扩展。

第一版最终代码

 public class ManualContainer : IManualContainer  {         private static Dictionary<string, Type> container = new Dictionary<string, Type>();         public void Register<TFrom, To>(string servicesName = null) where To : TFrom         {             string Key = $"{typeof(TFrom).FullName}{servicesName}";             if (!container.ContainsKey(Key))             {                 container.Add(Key, typeof(To));             }         }          public Tinterface Resolve<Tinterface>(string serviceName = null)         {             return (Tinterface)this.CreateInstance(typeof(Tinterface), serviceName);         }          private object CreateInstance(Type type, string serviceName = null)         {             string key = $"{ type.FullName }{serviceName}";             container.TryGetValue(key, out Type target);             object instance = ctorInjection(target);             propInjection(target, instance);             methodInjection(target, instance);             return instance;         }           /// <summary>         /// 构造函数注入         /// </summary>         /// <param name="target">需要被创建的类型</param>         /// <returns>被创建的实例</returns>         private object ctorInjection(Type targetType)         {             List<object> paramList = new List<object>();             ConstructorInfo ctor = null;             ctor = targetType.GetConstructors().FirstOrDefault(x => x.IsDefined(typeof(CtorInjectionAttribute), true));             if (ctor is null)             {                 ctor = targetType.GetConstructors().OrderByDescending(x => x.GetParameters().Length).First();             }             foreach (var item in ctor.GetParameters())             {                 Type paramType = item.ParameterType;                 string nickName = GetNickNameByAttribute(item);                 object instance = CreateInstance(paramType, nickName);                 if (instance != null)                 {                     paramList.Add(instance);                 }             }             object t = Activator.CreateInstance(targetType, paramList.ToArray());             return t;         }           /// <summary>         /// 属性注入         /// </summary>         /// <param name="targetType">需要被创建的类型</param>         /// <param name="sourceType">根据需要被创建的类型构造出的实例</param>         private void propInjection(Type targetType, object inststance)         {             var propetys = targetType.GetProperties().Where(x => x.IsDefined(typeof(PropInjectionAttribute), true));             foreach (var item in propetys)             {                 Type propType = item.PropertyType;                 string nickName = GetNickNameByAttribute(item);                 object obj = this.CreateInstance(propType, nickName);                 item.SetValue(inststance, obj);             }         }          /// <summary>         /// 方法注入         /// </summary>         /// <param name="targetType">需要被创建的类型</param>         /// <param name="sourceType">根据需要被创建的类型构造出的实例</param>         private void methodInjection(Type targetType, object inststance)         {             List<object> methodParams = new List<object>();             var methods = targetType.GetMethods().Where(x => x.IsDefined(typeof(MethodInjectionAttribute), true)).ToList();             foreach (var item in methods)             {                 foreach (var p in item.GetParameters())                 {                     Type propType = p.ParameterType;                     string nickName = GetNickNameByAttribute(item);                     object obj = this.CreateInstance(propType, nickName);                     methodParams.Add(obj);                 }                 item.Invoke(inststance, methodParams.ToArray());             }         }                  private string GetNickNameByAttribute(ICustomAttributeProvider provider)         {             if (provider.IsDefined(typeof(ParamterInjectAttribute), true))             {                 ParamterInjectAttribute attribute = provider.GetCustomAttributes(typeof(ParamterInjectAttribute), true)[0] as ParamterInjectAttribute;                 return attribute.NickName;             }             return string.Empty;         }   } 
赞(0) 打赏
未经允许不得转载:张拓的天空 » 手写IOC实践
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

专业的IT技术经验分享 更专业 更方便

联系我们本站主机

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏