网址：https://blog.csdn.net/wangyahua1234/article/details/100619695
目录
1. IoC简介
2. Tiny版IoC的功能
3. Tiny版IoC的实现
3.1 定制属性
3.2 IoC实现
4. Tiny版IoC的使用
5. 参考
1. IoC简介
IoC（Inversion of Control）翻译为“控制翻转”，这个“翻转”指的“获得依赖对象的过程被翻转了”。
IoC思想出现之前，我们想实例化一个对象，就必须在需要的地方new这个对象，然后才能使用这个对象中的成员。这样做的虽然很方便，但是久而久之代码中到处都是分散new的对象，且每个对象的生命周期都无法得到有效管理，最终导致对象管理成为项目开发的一个沉重的包袱。
如何摆脱这种困境呢——那就专门找一个模块做这个事情，这个模块就是IoC容器（容器是一种形象的说法，IoC就像一个碗，里面可以盛放对象，想要对象，不要再到处new了，直接从这个碗里面取）。
IoC的实现使得获取依赖对象的过程由自身管理变为由IoC主动注入，因此，IoC还有一个更容易理解的别名“依赖注入”。
2. Tiny版IoC的功能
目前有大量的IoC实现框架，比如Java Spring框架，.NET autofac框架，这些框架非常强大，本身的功能已经超出最初IoC设计的初衷，熟练使用起来还是需要费一些时间的。如果你的项目不是很庞大，但是也想好好管理对象，使代码清晰结构模块化，不妨自己来实现一个IoC容器。
下面给出的Tiny版IoC容器实现具有以下功能：
支持类的定制属性，指定其是否可被IoC容器扫描，以及如何实例化。
支持对象的单实例化（仅限默认构造函数）和多实例化；
以上两点基本可以满足部分中小型项目开发的应用场景了。
3. Tiny版IoC的实现
开发之前，你需要一些.NET for C#语言的知识储备：
定制属性
反射
泛型
IoC实现的核心，是“反射”机制。“定制属性”和“泛型”只是帮助你开发出可配置、通用化的、更好用的IoC容器。
3.1 定制属性
using System;
/// <summary>
/// 自定义类使用本定制属性时，将会被Ioc扫描，默认进行单实例化
/// 自定义类不使用本定制属性或使用本定制属性且带入"MultiInstance"参数，将会执行多实例化
/// </summary>
[AttributeUsage(AttributeTargets.Class)]
public class DependenceInjection : Attribute
{
public string InstanceType { get; set; }
/// <summary>
/// SingleInstance 单实例初始化，应用程序生命周期内只初始化一次；默认为单实例初始化。
/// MultiInstance 多实例初始化，每次调用，都将重新初始化一次。
/// </summary>
/// <param name="instanceType"></param>
public DependenceInjection(string instanceType = "SingleInstance")
{
this.InstanceType = instanceType;
}
}
3.2 IoC实现
说明：
利用反射机制获取程序集中的所有包含定制属性标记的类型；
根据定制属性类型进行实例化；
将该实例化对象，存放到IoC容器字典中；
单实例化对象，直接从IoC容器中取；
多实例化对象，也可由IoC代理进行自定义构造。
using System;
using System.Collections.Generic;
using System.Reflection;
using System.IO;
/// <summary>
/// 简易IoC容器类，可以通过定制属性DependenceInjection，来指定需要IoC容器扫描的类
/// </summary>
public static class IocHelper
{
public static Dictionary<Type, object> IocContainer = new Dictionary<Type, object>();
/// <summary>
/// 检索指定路径的程序集，注册带定制属性的类到IoC容器中
/// </summary>
/// <param name="assemblyPath">指定路径的程序集</param>
public static void Register(string assemblyPath)
{
if (Path.GetExtension(assemblyPath) != ".exe" && !File.Exists(assemblyPath))
throw new Exception(string.Format("程序集({0})不存在！", assemblyPath));
try
{
Assembly asb = Assembly.LoadFrom(assemblyPath);
var objetcList = asb.GetTypes();
if (objetcList.Any())
{
foreach (var obj in objetcList)
{
if (DoSingleInstance(obj))
{
//如果该类包含定制的属性且为要求执行单实例，则直接实例化
var objectInstance = Activator.CreateInstance(obj, null);
if (objectInstance != null)
IocContainer.Add(obj, objectInstance);
else
throw new Exception(string.Format("实例化对象{0}失败！", obj));
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 判断执行单实例化还是多实例化
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static bool DoSingleInstance(Type type)
{
Attribute[] attrs = Attribute.GetCustomAttributes(type);
foreach (var attr in attrs)
{
if (attr is DependenceInjection)
{
var di = (DependenceInjection)attr;
if (di.InstanceType == "SingleInstance")
{
return true;
}
}
}
return false;
}
/// <summary>
/// 实例化：
/// 单实例使用默认构造函数
/// 多实例可以自定义构造函数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="args"></param>
/// <returns></returns>
public static T Resolve<T>(params object[] args)
{
if (DoSingleInstance(typeof(T)))
{
if (IocContainer.ContainsKey(typeof(T)))
return (T)IocContainer[typeof(T)];
}
else
{
return (T)Activator.CreateInstance(typeof(T), args);
}
return default(T);
}
}
4. Tiny版IoC的使用
比较方便的使用场景是：直接让IoC扫描自己所在的应用程序，在程序运行的最开始处，注册应用程序中满足定制属性条件的对象。因为可以定制类的属性，因此我们可以做到IoC在扫描的时候，不会扫描到自己。
//User类被定制为可被IoC扫描的类，且只能单实例化（是用来默认参数）
[DependenceInjection()]
public class User
{
public void SayHello()
{
Console.WriteLine("Hello!");
}
}
//Book类没有被定制，因此不可被IoC扫描，但是可以由IoC代理进行构造初始化
public class Book
{
public void GetName()
{
Console.WriteLine("《哈利波特》");
}
}
//Book类被定制为可被IoC扫描的类，且可以多实例化
[DependenceInjection("MultyInstance")]
public class Food
{
public Food(string name)
{
Name = name;
}
public string Name { get; set; }
public void GetName()
{
Console.WriteLine(Name);
}
}
public class Program
{
public static void Main(string[] args)
{
//编译生成的程序集IoC.exe路径
IocHelper.Register(@"C:\Users\Administrator\Documents\Visual Studio 2015\Projects\IoC\IoC\bin\Debug\IoC.exe");
var user = IocHelper.Resolve<User>();
user?.SayHello();
var book = IocHelper.Resolve<Book>();
book?.GetName();
var food1 = IocHelper.Resolve<Food>("榴莲饼");
food1?.GetName();
var food2 = IocHelper.Resolve<Food>("烤香肠");
food2?.GetName();
Console.ReadKey();
}
}
执行，得到了你想要的实例化结果：
目录1. IoC简介2. Tiny版IoC的功能3. Tiny版IoC的实现3.1 定制属性3.2 IoC实现4. Tiny版IoC的使用5. 参考1. IoC简介IoC（Inversion of Control）翻译为“控制翻转”，这个“翻转”指的“获得依赖对象的过程被翻转了”。
IoC思想出现之前，我们想实例化一个对象，就必须在需要的地方new这个对象，然后才能使用这个对象中的成员。这样做的虽然很方便，但是久而久之代码中到处都是分散new的对象，且每个对象的生命周期都无法得到有效管理，最终导致对象管理成为项目开发的一个沉重的包袱。
如何摆脱这种困境呢——那就专门找一个模块做这个事情，这个模块就是IoC容器（容器是一种形象的说法，IoC就像一个碗，里面可以盛放对象，想要对象，不要再到处new了，直接从这个碗里面取）。
IoC的实现使得获取依赖对象的过程由自身管理变为由IoC主动注入，因此，IoC还有一个更容易理解的别名“依赖注入”。
2. Tiny版IoC的功能目前有大量的IoC实现框架，比如Java Spring框架，.NET autofac框架，这些框架非常强大，本身的功能已经超出最初IoC设计的初衷，熟练使用起来还是需要费一些时间的。如果你的项目不是很庞大，但是也想好好管理对象，使代码清晰结构模块化，不妨自己来实现一个IoC容器。
下面给出的Tiny版IoC容器实现具有以下功能：
支持类的定制属性，指定其是否可被IoC容器扫描，以及如何实例化。支持对象的单实例化（仅限默认构造函数）和多实例化；以上两点基本可以满足部分中小型项目开发的应用场景了。
3. Tiny版IoC的实现开发之前，你需要一些.NET for C#语言的知识储备：
定制属性反射泛型IoC实现的核心，是“反射”机制。“定制属性”和“泛型”只是帮助你开发出可配置、通用化的、更好用的IoC容器。
3.1 定制属性using System;/// <summary>/// 自定义类使用本定制属性时，将会被Ioc扫描，默认进行单实例化/// 自定义类不使用本定制属性或使用本定制属性且带入"MultiInstance"参数，将会执行多实例化/// </summary>[AttributeUsage(AttributeTargets.Class)]public class DependenceInjection : Attribute{ public string InstanceType { get; set; } /// <summary> /// SingleInstance 单实例初始化，应用程序生命周期内只初始化一次；默认为单实例初始化。 /// MultiInstance 多实例初始化，每次调用，都将重新初始化一次。 /// </summary> /// <param name="instanceType"></param> public DependenceInjection(string instanceType = "SingleInstance") { this.InstanceType = instanceType; }}12345678910111213141516171819203.2 IoC实现说明：
利用反射机制获取程序集中的所有包含定制属性标记的类型；根据定制属性类型进行实例化；将该实例化对象，存放到IoC容器字典中；单实例化对象，直接从IoC容器中取；多实例化对象，也可由IoC代理进行自定义构造。using System;using System.Collections.Generic;using System.Reflection;using System.IO;/// <summary> /// 简易IoC容器类，可以通过定制属性DependenceInjection，来指定需要IoC容器扫描的类 /// </summary> public static class IocHelper { public static Dictionary<Type, object> IocContainer = new Dictionary<Type, object>();
/// <summary> /// 检索指定路径的程序集，注册带定制属性的类到IoC容器中 /// </summary> /// <param name="assemblyPath">指定路径的程序集</param> public static void Register(string assemblyPath) { if (Path.GetExtension(assemblyPath) != ".exe" && !File.Exists(assemblyPath)) throw new Exception(string.Format("程序集({0})不存在！", assemblyPath)); try { Assembly asb = Assembly.LoadFrom(assemblyPath); var objetcList = asb.GetTypes();
if (objetcList.Any()) { foreach (var obj in objetcList) { if (DoSingleInstance(obj)) { //如果该类包含定制的属性且为要求执行单实例，则直接实例化 var objectInstance = Activator.CreateInstance(obj, null); if (objectInstance != null) IocContainer.Add(obj, objectInstance); else throw new Exception(string.Format("实例化对象{0}失败！", obj)); }
} } } catch (Exception ex) { throw ex; } }
/// <summary> /// 判断执行单实例化还是多实例化 /// </summary> /// <param name="type"></param> /// <returns></returns> private static bool DoSingleInstance(Type type) { Attribute[] attrs = Attribute.GetCustomAttributes(type);
foreach (var attr in attrs) { if (attr is DependenceInjection) { var di = (DependenceInjection)attr; if (di.InstanceType == "SingleInstance") { return true; } } }
return false; }
/// <summary> /// 实例化： /// 单实例使用默认构造函数 /// 多实例可以自定义构造函数 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="args"></param> /// <returns></returns> public static T Resolve<T>(params object[] args) { if (DoSingleInstance(typeof(T))) { if (IocContainer.ContainsKey(typeof(T))) return (T)IocContainer[typeof(T)]; } else { return (T)Activator.CreateInstance(typeof(T), args); }
return default(T); } }12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394954. Tiny版IoC的使用比较方便的使用场景是：直接让IoC扫描自己所在的应用程序，在程序运行的最开始处，注册应用程序中满足定制属性条件的对象。因为可以定制类的属性，因此我们可以做到IoC在扫描的时候，不会扫描到自己。
//User类被定制为可被IoC扫描的类，且只能单实例化（是用来默认参数）[DependenceInjection()] public class User { public void SayHello() { Console.WriteLine("Hello!"); } }
//Book类没有被定制，因此不可被IoC扫描，但是可以由IoC代理进行构造初始化 public class Book { public void GetName() { Console.WriteLine("《哈利波特》"); } }
//Book类被定制为可被IoC扫描的类，且可以多实例化 [DependenceInjection("MultyInstance")] public class Food { public Food(string name) { Name = name; }
public string Name { get; set; } public void GetName() { Console.WriteLine(Name); } }
public class Program { public static void Main(string[] args) { //编译生成的程序集IoC.exe路径 IocHelper.Register(@"C:\Users\Administrator\Documents\Visual Studio 2015\Projects\IoC\IoC\bin\Debug\IoC.exe");
var user = IocHelper.Resolve<User>(); user?.SayHello();
var book = IocHelper.Resolve<Book>(); book?.GetName();
var food1 = IocHelper.Resolve<Food>("榴莲饼"); food1?.GetName();
var food2 = IocHelper.Resolve<Food>("烤香肠"); food2?.GetName();
Console.ReadKey(); } }123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657执行，得到了你想要的实例化结果：
————————————————版权声明：本文为CSDN博主「yahua_king」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/wangyahua1234/article/details/100619695