.NET实现IoC

在代码1-9中，IoCKernel实现了IIoCKernel接口，首先在其构造函数中，我们对抽象、具体关系维护的对象进行了初始化，并且设置到了当前IoC框架的上下文中，我们这里先停一下，看一下抽象、具体关系维护对象的构造，示例代码1-10.

代码1-10

namespace FrameWork.IoC.Achieve.IoCBasics
{/// 
/// DI类型关系信息管理/// public class DITypeInfoManage{private Dictionary _DITypeInfo;public DITypeInfoManage(){_DITypeInfo = new Dictionary();}/// 
/// 添加DI类型关系/// /// 抽象类型/// 实现类型public void AddTypeInfo(Type key, Type value){if (key == null){throw new ArgumentNullException("key");}if (_DITypeInfo.ContainsKey(key)){return;}if (value == null){throw new ArgumentNullException("value");}_DITypeInfo.Add(key, value);}/// 
/// 获取DI类型关系的实现类型/// /// 抽象类型/// public Type GetTypeInfo(Type key){if (key == null){throw new ArgumentNullException("key");}if (_DITypeInfo.ContainsKey(key)){return _DITypeInfo[key];}return null;}public bool ContainsKey(Type key){if (key == null){throw new ArgumentNullException("key");}return _DITypeInfo.ContainsKey(key);}}
}

DITypeInfoManage类型对象表示着抽象、具体类型关系的信息维护，实则就是在内部封装了键值队，这里就不多说了，然后我们再看一下代码1-9中IoC框架入口点类型的构造函数中初始化DITypeInfoManage类型设置的上下文对象，来看示例代码1-11.

using FrameWork.IoC.Achieve.IoCAbstractBasics;
using FrameWork.IoC.Achieve.Providers;
using FrameWork.IoC.Achieve.IoCBasics;namespace FrameWork.IoC.Achieve
{public class IoCContext{private IoCContext() { }private static IoCContext _Context;public static IoCContext Context{get {if (_Context == null){_Context = new IoCContext();}return _Context;}}private IDITypeAnalyticalProvider _DITypeAnalyticalProvider;public IDITypeAnalyticalProvider DITypeAnalyticalProvider{get{if (_DITypeAnalyticalProvider == null){_DITypeAnalyticalProvider = new DefualtDITypeAnalyticalProivder();}return _DITypeAnalyticalProvider;}set{_DITypeAnalyticalProvider = value;}}private DITypeInfoManage _DITypeInfoManage;public DITypeInfoManage DITyoeInfoManage{get{return _DITypeInfoManage;}set{_DITypeInfoManage = value;}}}
}

代码1-11中的定义的IoCContext说是上下文对象，说是这么说，用以维护框架中必要的信息，实则就是一个单例模式的对象，但是意义上它还是上下文对象，在这个对象里面维护着所要依赖注入的抽象、具体类型维护的对象，这个对象我们上面代码1-10看过了，还有一个就是分析上层类型的提供程序对象，分析上层类型的提供程序对象是用以生成分析上层类型对象的，这样做便于对外扩展，我们就这样顺着往下看，看一下分析上层类型的提供程序对象，示例代码1-12。

代码1-12

using FrameWork.IoC.Achieve.IoCAbstractBasics;namespace FrameWork.IoC.Achieve.Providers
{public interface IDITypeAnalyticalProvider{IDITypeAnalytical CreteDITypeAnalaytical();}
}

这里的IDITypeAnalytical接口类型就是分析类型的抽象，在提供程序抽象中用以它来做返回类型，这也遵循着依赖倒置原则B条的抽象不依赖于具体。现在我们来看一下默认实现，示例代码1-13.

代码1-13

using FrameWork.IoC.Achieve.IoCAbstractBasics;
using FrameWork.IoC.Achieve.IoCBasics;namespace FrameWork.IoC.Achieve.Providers
{public class DefualtDITypeAnalyticalProivder:IDITypeAnalyticalProvider{public IDITypeAnalytical CreteDITypeAnalaytical(){return new DITypeAnalytical();}}
}

在代码1-13中定义的就是默认的分析上层类型提供程序了，默认返回的就是我们框架中默认的分析上层类型对象，现在我们就来看一下分析上层类型对象的抽象和具体实现，示例代码1-14。

代码1-14

namespace FrameWork.IoC.Achieve.IoCAbstractBasics
{public interface IDITypeAnalytical{T GetValue();}
}

只是定义了一个泛型的GetValue()方法，泛型类型当然就是所需要执行依赖注入并且生成的上层对象类型了，这里没什么好说的，直接来看分析上层类型的具体实现吧，示例代码1-15.

代码1-15

using FrameWork.IoC.Achieve.IoCAbstractBasics;
using System.Reflection;namespace FrameWork.IoC.Achieve.IoCBasics
{public class DITypeAnalytical : IDITypeAnalytical{public T GetValue(){Type type = typeof(T);return (T)TypeAnalytical(type);}private object TypeAnalytical(Type type){ConstructorInfo[] constructorInfos = type.GetConstructors();object instance = null;#region 构造函数注入foreach (ConstructorInfo conInfo in constructorInfos){if (conInfo.GetParameters().Length > 0){ParameterInfo[] paras = conInfo.GetParameters();List<object> args = new List<object>();foreach (ParameterInfo para in paras){if (IoCContext.Context.DITyoeInfoManage.ContainsKey(para.ParameterType)){object par = TypeAnalytical(IoCContext.Context.DITyoeInfoManage.GetTypeInfo(para.ParameterType));args.Add(par);}}instance = CreateInstance(type, args.ToArray());break;}}#endregionif (instance == null){instance = CreateInstance(type);}#region 属性注入if (type.GetProperties().Length > 0){PropertyInfo[] proertyInfos = type.GetProperties();foreach (PropertyInfo propertyInfo in proertyInfos){if (propertyInfo.GetCustomAttributes(typeof(DITypeAttribute), false).Length > 0){if (IoCContext.Context.DITyoeInfoManage.ContainsKey(propertyInfo.PropertyType)){object propertyvalue = TypeAnalytical(IoCContext.Context.DITyoeInfoManage.GetTypeInfo(propertyInfo.PropertyType));propertyInfo.SetValue(instance, propertyvalue, null);}}}}#endregionreturn instance;}private object CreateInstance(Type type,params object[] args){return Activator.CreateInstance(type, args);}}
}

在代码1-15的定义中，主要的核心功能在TypeAnalytical()方法中，这里主要说明一下这个方法的执行过程，首先是根据方法参数传入的类型，这个类型就是要实现依赖注入的类型，为什么不说这个参数类型是上层类型？

是因为在首先执行的过程中传入的是上层类型，然后判断其类型的构造函数，读取构造函数的参数类型根据【抽象、具体类型的维护对象】来查找当前上层类型是否需要进行构造函数依赖，如果【抽象、具体类型的维护对象】中存在所需的类型，则对上层类型的构造函数参数类型进行实例创建，并且再次调用TypeAnalytical()方法，因为我们不能确定上层类型构造函数的参数类型是否需要进行依赖注入，所以这里是递归的。

在创建完上层类型构造函数的参数类型实例后，便会对上层类型进行实例创建，因为这是依赖注入中构造函数注入的一种方式。

在此完毕后判断TypeAnalytical()方法中instance实例是否为空，如果是空的则说明上层类型没有采取构造函数注入的方式，在此我们还是要创建它的实例，以便下面的进行属性注入时对实例属性的赋值。

之后我们会对上层类型的所有公共属性根据条件进行查找，查找符合我们定义标准的公共属性，也就是DITypeAttribute类型，这个类型下面会贴出示例代码，假使在找到需要依赖注入的公共属性后执行过程便和上面执行构造函数注入的方式相同。

(ps:这里功能的定义并不是很严谨，而且只针对了构造函数注入和属性注入两种方式，并没有对接口注入提供支持。)

下面我们看一下上面所说的属性注入的特性类定义（也就是框架定义的规范），示例代码1-16.

代码1-16

namespace FrameWork.IoC.Achieve.IoCBasics
{[AttributeUsage(AttributeTargets.Property,AllowMultiple=false,Inherited=false)]public class DITypeAttribute:Attribute{public DITypeAttribute() { }}
}

就是一个简单的特性类定义，用作规范约束。

最后我们看一下测试用例：

代码1-17

using FrameWork.IoC.Achieve.IoCBasics;
using FrameWork.IoC.Achieve.IoCAbstractBasics;using FrameWork.IoC.Case;
using FrameWork.IoC.Case.Test.TestOne;
using FrameWork.IoC.Case.Test.TestTwo;namespace FrameWork.IoC.Case.Test
{public class DITest{private IAbstractOne _AbstractOne;public DITest(IAbstractOne abstractone){_AbstractOne = abstractone;}private IAbstractTwo _AbstractTwo;[DIType]public IAbstractTwo AbstractTwo{get{return _AbstractTwo;}set{_AbstractTwo = value;}}public void Writer(string meg){_AbstractOne.WriterLine(meg);_AbstractTwo.WriterLine(meg);}}
}

代码1-17定义中对DITest分别进行了构造函数、属性注入，注入类型分别对应着IAbstractOne、IAbstractTwo。我们先来看一下IAbstractOne抽象、具体的定义，示例代码1-18

代码1-18

namespace FrameWork.IoC.Case.Test.TestOne
{public interface IAbstractOne{void WriterLine(string meg);}public class AchieveOne:IAbstractOne{private IAbstractOne_One _AbstractOne_One;public AchieveOne(IAbstractOne_One abstractone){_AbstractOne_One = abstractone;}private IAbstractOne_Two _AbstractOne_Two;[DIType]public IAbstractOne_Two AbstractOne_Two{get{return _AbstractOne_Two;}set{_AbstractOne_Two = value;}}public void WriterLine(string meg){_AbstractOne_One.WirterLine(meg);_AbstractOne_Two.WriterLine(meg);Console.WriteLine(meg + "-This is TestOne");}}}

代码1-18中定义了IAbstractOne抽象、AchieveOne具体实现，并且在AchieveOne具体实现中还对IAbstractOne_One、IAbstractOne_Two分别进行了构造函数、属性注入。从最上层来看就是嵌套的注入，这样更能体现出IoC框架的重要性。

我们看一下IAbstractOne_One、IAbstractOne_Two类型的抽象、具体定义，示例代码1-19.

代码1-19

namespace FrameWork.IoC.Case.Test.TestOne
{public interface IAbstractOne_One{void WirterLine(string meg);}    public class AbstractOne_One:IAbstractOne_One{public void WirterLine(string meg){Console.WriteLine(meg + "-This is TestOne_One");}}    public interface IAbstractOne_Two{void WriterLine(string meg);}public class AbstractOne_Two:IAbstractOne_Two{public void WriterLine(string meg){Console.WriteLine(meg + "-This is TestOne_Two");}}}

最后我们再看一下IAbstractTwo抽象和具体实现的定义，示例代码1-20.

代码1-20

namespace FrameWork.IoC.Case.Test.TestTwo
{public interface IAbstractTwo{void WriterLine(string meg);}public class AchieveTwo:IAbstractTwo{public void WriterLine(string meg){Console.WriteLine(meg + "-This is TestTwo");}}}

真的是最后我们看一下客户端的调用代码，示例代码1-21，

代码1-21

using FrameWork.IoC.Achieve.IoCBasics;
using FrameWork.IoC.Achieve.IoCAbstractBasics;using FrameWork.IoC.Case;
using FrameWork.IoC.Case.Test;
using FrameWork.IoC.Case.Test.TestOne;
using FrameWork.IoC.Case.Test.TestTwo;namespace FrameWork.IoC.Case
{class Program{static void Main(string[] args){#region IoCTestIIoCKernel iocKernel = new IoCKernel();iocKernel.Bind().To();iocKernel.Bind().To();iocKernel.Bind().To();iocKernel.Bind().To();DITest diType = iocKernel.GetValue();diType.Writer("IoCFrameWorkTest");#endregionConsole.ReadLine();}}
}

最后看一下结果，如图7

图7

到这里本篇的内容就结束了，自定义IoC只是一个参考，并没有对IoC框架进行深入的实现，只是以此做一个引导，建议大家还是选择一款合适的IoC框架当作学习的对象，当然感兴趣的朋友还是可以自己写的。

搬砖不易，且搬且用心，感谢各位工友的支持，谢谢大家。

作者：金源

出处：http://www.cnblogs.com/jin-yuan/

转载于:https://www.cnblogs.com/sunzhao/p/8334336.html

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！