「这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战」
一、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是相对比较久远的框架，用的比较少。
-
AutoFac
-
Castle
-
Unity
-
ObjectBuilder
二、如何手写实现？
1.基本设计
核心思想： 工厂 + 反射
首先我们想自己实现一个IoC容器其实并不难，我们在使用现有的IoC容器都知道，在使用前，我们需要先注册，然后才能使用
所以我们将工厂换成手动注册的方式，因为写一大堆if else 或者switch也不太美观，根据主流IoC的使用方式来以葫芦画瓢，如果后期继续完善功能加入程序集注入的话，还是得实现一个工厂，来省略手动注册
但是这次目标是实现一个简易版的IoC容器,我们先实现基础功能，待后面一步一步去完善，再加入一些新的功能，即我们不考虑性能或者扩展度，目的是循序渐进，在写之前我们先整理出 实现步骤和实现方式
-
方便接入和扩展，我们在这先定义一个容器接口 IManualContainer
-
定义ManualContainer继承实现IManualContainer
-
声明一个静态字典对象存储注册的对象
-
利用反射构建对象，考虑到性能可以加入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>() where To : TFrom;
TFrom Resolve<TFrom>();
}
复制代码2.要实现的功能
1.基本对象构造
2.构造函数注入
3.多级依赖和多构造函数及自定义注入
4.属性注入&方法注入
5.单接口多实现
6.构造传入实例类型
三、编码实现及思路剖析
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>() where To : TFrom
{
string Key = typeof(TFrom).FullName;
if (!container.ContainsKey(Key))
{
container.Add(Key, typeof(To));
}
}
复制代码1.实现构造对象，首先需要传入被构造的类型的抽象接口T
2.在Resolve中根据T作为Key,在存储容器中找到注册时映射的类型，并通过反射构造对象
//构建对象
public TFrom Resolve<TFrom>()
{
string key = typeof(TFrom).FullName;
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缺少构造参数，那么我们就需要在反射构造时加入参数。
-
先定义List<object>集合存储对象构造时需要的参数列表
-
通过需要被实例的目标类型找到类中的构造函数，暂不考虑多构造函数case
-
找到构造函数参数及类型，然后创建参数的实例加入List中,在反射构造时传入参数就解决了
//完善Resolve构建对象函数
public TFrom Resolve<TFrom>()
{
string key = typeof(TFrom).FullName;
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.多级依赖（递归）
根据上面我们目前实现的结果来看,这是解决了构造函数和多参数注入以及基本的构造对象问题，那现在问题又来了
-
如果是很多层的依赖该怎么办？
-
例如多个构造函数怎么办呢？
-
在多个构造函数中用户想自定义需要被注入的构造函数怎么办？
总结3点问题
- 1.多级依赖问题
例如ITestB 的实例中依赖ITestC,一直无限依赖我们怎么解决呢？毫无疑问，做同样的事情，但是要无限做下去，就使用 递归,下面我们来改造我们的方法
-
2.多个构造函数
-
取参数最多的方式注入 (AutoFac)
-
取并集方式注入 (ASP .NET Core)
-
-
3.自定义注入
我们可以使用特性标记的方式来实现，用户在需要被选择注入的构造函数上加入特性标签来完成
1.创建私有递归方法，这个方法的作用就是创建对象用
private object CreateInstance(Type type)
{
}
复制代码2.我们选择第一种方式实现,修改之前获取第一个构造函数的代码，选择最多参数注入
//找到目标类型的构造函数，找参数最多的构造函数
ConstructorInfo ctor = null;
var ctors = target.GetConstructors();
ctor = ctors.OrderByDescending(x => x.GetParameters().Length).First();
复制代码3.自定义特性ManualCtorInjection，可以使用户自定义选择
//自定义构造函数注入标记
[AttributeUsage(AttributeTargets.Constructor)]
public class ManualCtorInjectionAttribute : Attribute
{
}
复制代码4.最终代码
private object CreateInstance(Type type)
{
string key = type.FullName;
container.TryGetValue(key, out Type target);
//存储参数列表
List<object> paramList = new List<object>();
ConstructorInfo ctor = null;
//找到被特性标记的构造函数作为注入目标
ctor = target.GetConstructors().FirstOrDefault(x => x.IsDefined(typeof(ManualInjectionAttribute), 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.自定义特性ManualPropInjection，可以使用户自定义选择
//自定义构造属性注入标记
[AttributeUsage(AttributeTargets.Constructor)]
public class ManualPropInjectionAttribute : Attribute
{
}
//自定义构造方法注入标记
[AttributeUsage(AttributeTargets.Method)]
public class ManualMethodInjectionAttribute : Attribute
{
}
复制代码2.遍历实例中被标记特性的属性。
3.获取属性的类型，调用递归构造对象函数。
4.设置目标对象的属性值。
5.方法注入也是同理，换汤不换药而已
private object CreateInstance(Type type)
{
string key = type.FullName;
container.TryGetValue(key, out Type target);
//存储参数列表
List<object> paramList = new List<object>();
ConstructorInfo ctor = null;
//找到被特性标记的构造函数作为注入目标
ctor = target.GetConstructors().FirstOrDefault(x => x.IsDefined(typeof(ManualInjectionAttribute), 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(ManualPropertyInjectionAttribute), 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(ManualMethodInjectionAttribute), true)).ToList();
foreach (var item in methods)
{
//获取方法参数类型
Type propType = item.GetParameters()[0].ParameterType;
object obj = this.CreateInstance(propType);
item.Invoke(t,new object[] { obj});
}
return t;
}
public TFrom Resolve<TFrom>()
{
return (TFrom)this.CreateInstance(typeof(TFrom));
}
复制代码5.单接口多实现
1.在注册时传入一个别名参数同接口类型组合Key
public void Register<TFrom, To>(string servicesName) where To : TFrom
{
string Key = typeof(TFrom).FullName + servicesName;
if (!container.ContainsKey(Key))
{
container.Add(Key, typeof(To));
}
}
复制代码2.在构造对象时传入别名,根据目标类型和别名组合key找到注册时需要创建的实例类型
public Tinterface Resolve<Tinterface>(string servicesName)
{
return (Tinterface)this.CreateInstance(typeof(Tinterface), servicesName);
}
复制代码6.构造传入实例类型
1.必须注册时传入实例参数，先存起来，到构造时然后传入
四、总结
目前还不是很完善，只是实现了属性,方法,以及构造函数注入，很多必要功能还没有，下一步将在现有代码基础上利用Emit的方式来创建对象，加入基本的验证环节以提高健壮性,加入生命周期管理，和AOP扩展。