从0开始搭建一个IoC容器（C#版）

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容器实现具有以下功能：

1. 支持类的定制属性，指定其是否可被IoC容器扫描，以及如何实例化。
2. 支持对象的单实例化（仅限默认构造函数）和多实例化；

以上两点基本可以满足部分中小型项目开发的应用场景了。

3. Tiny版IoC的实现

开发之前，你需要一些.NET for C#语言的知识储备：

1. 定制属性
2. 反射
3. 泛型

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实现

说明：

1. 利用反射机制获取程序集中的所有包含定制属性标记的类型；
2. 根据定制属性类型进行实例化；
3. 将该实例化对象，存放到IoC容器字典中；
4. 单实例化对象，直接从IoC容器中取；
5. 多实例化对象，也可由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();
        }
    }

执行，得到了你想要的实例化结果：

5. 参考

Spring的IOC原理[通俗解释一下]
C#自定义应用程序上下文对象+IOC自己实现依赖注入