<二>IOC&DI 简单实现
一、IOC 控制反转
面向对象编程的一种设计原则，可以用来降低代码之间的耦合度。
IOC容器：就是专门做实例化的工厂。
二、依赖倒置
一种设计模式，以前是高层依赖低层，现在不这么干了，所有层级都依赖于抽象，并且负责实现自己继承的抽象。
三、实现
IOC实现的三步：1、注册Register,先告诉IOC抽象与实现的关系。2、有了关系才有了Resolve生成实例。3、有了实例就能依赖IOC容器注入实例。
1、实现register和Resolve
在上一节的common中添加两个类，叫TestContainer和接口ITestContainer。
public interface ITestContainer { /// <summary> /// 注册抽象与实例的映射关系 /// </summary> /// <typeparam name="IT"></typeparam> /// <typeparam name="T"></typeparam> void Register<IT, T>() where T : IT; /// <summary> /// 通过映射返回实例 /// </summary> /// <typeparam name="IT"></typeparam> /// <returns></returns> IT Resolve<IT>(); }
public class TestContainer:ITestContainer { /// <summary> /// 映射字典 /// </summary> private Dictionary<string, Type> RegisterTypes = new Dictionary<string, Type>(); /// <summary> /// 注册 /// </summary> /// <typeparam name="IT">抽象</typeparam> /// <typeparam name="T">实现抽象细节</typeparam> public void Register<IT, T>() where T : IT { string key = typeof(IT).FullName; if (!RegisterTypes.ContainsKey(key)) { RegisterTypes.Add(key, typeof(T)); } } /// <summary> /// 返回实例 /// </summary> /// <typeparam name="IT"></typeparam> /// <returns></returns> /// <exception cref="Exception"></exception> public IT Resolve<IT>() { string key = typeof(IT).FullName; if (!RegisterTypes.ContainsKey(key)) { throw new Exception($"未注册{key},不能被实例化!"); } Type instanceType = RegisterTypes[key]; Object instance = Activator.CreateInstance(instanceType); return (IT)instance; } }
如上代码，Register方法将注册进来的抽象名和实例的映射保存到一个字典里，Resolve方法，通过传进来的抽象去注册映射字典里找到对应的实现细节类，并返回该实现类的实例。
ITestContainer container=new TestContainer(); container.Register<IUserDal,UserMySqlDal>(); IUserDal userDal = container.Resolve<IUserDal>(); IUserBll userBll = Factory.CreateBll(userDal); bool result= userBll.Login(1); Console.WriteLine(result);
如上，修改一下UI层的代码，先调用Register注册userDal的关联，然后再用Resolve实例化方法返回实例。可以实现。
2、实现构造函数注入实例（依赖注入）
上面我们只是实现了简单的一个注册和实例化方法。只能对UserDal这种只有无参构造方法的类进行实例化。遇到像UserBll这个需要传一个IUserDal参数的构造方法，那就会报错了。
那么如果要实现这种构造函数带一个参数的类呢？只有先实例了UserDal再去实例UserBll。修改一下revolse的方法。
public IT Resolve<IT>() { string key = typeof(IT).FullName; if (!RegisterTypes.ContainsKey(key)) { throw new Exception($"未注册{key},不能被实例化!"); } Type instanceType = RegisterTypes[key]; ConstructorInfo userConstructor = null; //使用的构造方法 ConstructorInfo[] constructors=instanceType.GetConstructors();//获取类所有的构造方法 //获取构造方法 if (constructors != null && constructors.Length > 0) { foreach (var constructor in constructors) { userConstructor = constructor; //暂时取第一个 break; } } //保存参数的实例 List<object> constructorParamInfos = new List<object>(); //获取构造方法的参数 if (userConstructor != null) { ParameterInfo[] paramInfos= userConstructor.GetParameters(); if (paramInfos != null && paramInfos.Length > 0) { foreach (ParameterInfo pInfo in paramInfos) { //对参数进行实例化 Type pType= pInfo.ParameterType; string pTypeKey = pType.FullName; if (RegisterTypes.ContainsKey(pTypeKey)) { Type pInstanceType = RegisterTypes[pTypeKey]; Object pInstance = Activator.CreateInstance(pInstanceType); constructorParamInfos.Add(pInstance); } else { throw new Exception($"未注册{pTypeKey},不能被实例化!"); } } } } Object instance = null; if(constructorParamInfos.Count()>0) { instance = Activator.CreateInstance(instanceType,constructorParamInfos.ToArray()); } else { instance = Activator.CreateInstance(instanceType); } return (IT)instance; }
如上述代码，先通过反射获取实例类型的所有构造方法，暂时先取第一个构造方法，获取构造方法中的所有参数，遍历参数并实现参数的实例化加到参数实例集合里。这叫什么？这个实现就叫做依赖注入。即在构造B对象的过程中发现B依赖于A对象，那么在构造B对象的时候能够动态的构造A对象并传递给B,让B能够正常的通过构造方法进行实例化。
3、依赖注入的好处
下面对比一下用factory实例UserBll和使用依赖注入实例UserBll。依赖注入屏蔽掉了实例UserDAL的细节。而一般工厂必须要接收UserDal的实例才能去实例UserBLL。那如果UserBll的构造方法依赖100个其他实例，那么还需要先实例化100个实例再传给UserBll构造方法。这代码写下来，手酸不说，这样的代码好吗？所以依赖注入的好处便是上端不再需要去实现实例UserBll的所有细节，就是不管你UserBll的实例化需要依赖多少其他实例，我只需要写一条语句就行。
ITestContainer container = new TestContainer(); container.Register<IUserDal, UserMySqlDal>(); container.Register<IUserBll, UserBll>(); IUserBll userBll = container.Resolve<IUserBll>(); //依赖注入实现实例 //IUserDal userDal = container.Resolve<IUserDal>(); // //IUserBll userBll = Factory.CreateBll(userDal); //工厂生成实例 bool result = userBll.Login(1); Console.WriteLine(result);
4、递归实现多层依赖注入
上面我们实现了一层的构造方法调用，那如果UserDal的构造方法需要传入一个另一个对象呢？即UserBll需要先构造UserDal,要构造UserDal需要先构造UserContext。这个时候怎么实现呢？这种结构是不是树结构？那么遍历树的算法有很多种（有兴趣可以去研究下数据结构与算法）。递归应该是最简单的了，那么就用递归来实现吧。递归存在内存泄露的风险，实际项目中最好避免使用。修改代码
加一个IUserContext,和UserContext，再给UserMysqlDal加上构造函数。
public class UserMySqlDal:IUserDal { private IUserContext UserContext { get; set; } public UserMySqlDal(IUserContext userContext) { UserContext = userContext; } public object Find(int id) { return null; } }
public IT Resolve<IT>() { Type type = typeof(IT); object instance = ResolveObject(type); return (IT)instance; } /// <summary> /// 递归实例化对象 /// </summary> /// <param name="objectType"></param> /// <returns></returns> /// <exception cref="Exception"></exception> private object ResolveObject(Type objectType) { string key = objectType.FullName; if (!RegisterTypes.ContainsKey(key)) { throw new Exception($"未注册{key},不能被实例化!"); } Type instanceType = RegisterTypes[key]; ConstructorInfo userConstructor = null; //使用的构造方法 ConstructorInfo[] constructors=instanceType.GetConstructors();//获取类所有的构造方法 //获取构造方法 if (constructors != null && constructors.Length > 0) { foreach (var constructor in constructors) { userConstructor = constructor; //暂时取第一个 break; } } //保存参数的实例 List<object> constructorParamInfos = new List<object>(); //获取构造方法的参数 if (userConstructor != null) { ParameterInfo[] paramInfos= userConstructor.GetParameters(); if (paramInfos != null && paramInfos.Length > 0) { foreach (ParameterInfo pInfo in paramInfos) { //对参数进行实例化 Type pType= pInfo.ParameterType; Object pInstance = ResolveObject(pType); constructorParamInfos.Add(pInstance); //string pTypeKey = pType.FullName; //if (RegisterTypes.ContainsKey(pTypeKey)) //{ // Type pInstanceType = RegisterTypes[pTypeKey]; // Object pInstance = Activator.CreateInstance(pInstanceType); // constructorParamInfos.Add(pInstance); //} //else //{ // throw new Exception($"未注册{pTypeKey},不能被实例化!"); //} } } } Object instance = null; if(constructorParamInfos.Count()>0) { instance = Activator.CreateInstance(instanceType,constructorParamInfos.ToArray()); } else { instance = Activator.CreateInstance(instanceType); } return instance; }
5、处理构造方法优先选择
上面的代码选择构造方法构造的时候暂时选取的是第一个。这个显然是不合理的。Unity和autofac采用的是参数最多的构造方法，而.netcore内置的IOC采用的时候参数的类型最多的构造方法。这两种默认算法这里就不写了，还有另一种叫指定方式。指定方式怎么指定呢？可以利用特性来指定。
public class DefaultInstantiateAttribute: Attribute { }
//获取构造方法 if (constructors != null && constructors.Length > 0) { //获取第一个特性指定的构造方法 var defaultConstructor = constructors.Where(c => c.IsDefined(typeof(DefaultMemberAttribute), true)).ToList(); ; if (defaultConstructor != null&& defaultConstructor.Count()>0) { userConstructor = defaultConstructor[0]; } else { foreach (var constructor in constructors) { ///实现构造方法的优先选择 userConstructor = constructor; //暂时取第一个 break; } } }
四、总结
IOC(控制反转)：是一种设计模式。
DI(依赖注入)：是一种实现方式。
