IoC原理-使用反射/Emit来实现一个最简单的IoC容器

参考文章https://www.cnblogs.com/kklldog/p/3395641.html与https://www.cnblogs.com/MedlarCanFly/p/11430057.html

 #region

    #region 1.定义IIoCConfig接口
    public interface IIoCConfig
    {
        void AddConfig<TInterface, TType>();

        Dictionary<Type, Type> ConfigDictionary { get; }
    }
    #endregion
    //试过两者在emit和Activator.CreateInstance两者获得实现。Activator.CreateInstance效率更高
    #region 2.定义IoCConfig实现

    //使用一个字典来保存Interface跟Class的对应关系。这里是仿造Ninject的配置方式，使用代码来配置。
    //这种配置方式有个好处就是不会写错，因为有IDE来给你检查拼写错误。不要小看这个好处，
    //当你有上百个注入对象的时候，使用Unity的XML来配置对应关系的时候很容易就会发生拼写错误。这种错误往往还很难发现。
    //当然这里要实现一个按照XML配置文件来设置对应关系的类也很容易，这里就不实现了。
    public class IoCConfig : IIoCConfig
    {
        public Dictionary<Type, Type> ConfigDictionary { get; } = new Dictionary<Type, Type>();

        /// <summary>
        /// 添加配置
        /// </summary>
        /// <typeparam name="TInterface">接口</typeparam>
        /// <typeparam name="TType">实现接口的类型</typeparam>
        public void AddConfig<TInterface, TType>()
        {
            //判断TType是否实现TInterface
            if (typeof(TInterface).IsAssignableFrom(typeof(TType)))
            {
                ConfigDictionary.Add(typeof(TInterface), typeof(TType));
            }
            else
            {
                throw new Exception("类型未实现接口");
            }
        }
    }
    #endregion

    #region 3.定义IIoCContainer容器接口
    /// <summary>
    /// ioc容器接口
    /// </summary>
    public interface IIoCContainer
    {
        /// <summary>
        /// 根据接口返回对应的实例
        /// </summary>
        /// <typeparam name="TInterface"></typeparam>
        /// <returns></returns>
        TInterface Get<TInterface>();
    }
    #endregion

    #region 4.使用反射实现IoC容器
    /// <summary>
    /// 使用反射实现IoC容器
    /// </summary>
    public class ReflectionContainer : IIoCContainer
    {
        /// <summary>
        /// 配置实例
        /// </summary>
        private IIoCConfig _config;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="config">ioc配置</param>
        public ReflectionContainer(IIoCConfig config)
        {
            _config = config;
        }

        /// <summary>
        /// 根据接口获取实例对象
        /// </summary>
        /// <typeparam name="TInterface">接口</typeparam>
        /// <returns></returns>
        public TInterface Get<TInterface>()
        {
            Type type;
            var can = _config.ConfigDictionary.TryGetValue(typeof(TInterface), out type);
            if (can)
            {
                //反射实例化对象
                return (TInterface)Activator.CreateInstance(type);
            }
            else
            {
                throw new Exception("未找到对应的类型");
            }
        }
    }
    #endregion
    /// <summary>
    /// 使用Emit实现IoC容器
    /// </summary>
    public class EmitContainer : IIoCContainer
    {
        /// <summary>
        /// 配置实例
        /// </summary>
        private IIoCConfig _config;

        public EmitContainer(IIoCConfig config)
        {
            _config = config;
        }

        /// <summary>
        /// 获取实例
        /// </summary>
        /// <typeparam name="TInterface">接口</typeparam>
        /// <returns></returns>
        public TInterface Get<TInterface>()
        {
            Type type;
            var can = _config.ConfigDictionary.TryGetValue(typeof(TInterface), out type);
            if (can)
            {
                BindingFlags defaultFlags = BindingFlags.Public | BindingFlags.Instance;
                var constructors = type.GetConstructors(defaultFlags);//获取默认构造函数
                var t = (TInterface)this.CreateInstanceByEmit(constructors[0]);
                return t;
            }
            else
            {
                throw new Exception("未找到对应的类型");
            }
        }

        /// <summary>
        /// 实例化对象 用EMIT
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="constructor">构造函数信息</param>
        /// <returns></returns>
        private Object CreateInstanceByEmit(ConstructorInfo constructor)
        {
            //动态方法
            var dynamicMethod = new DynamicMethod(Guid.NewGuid().ToString("N"), typeof(Object), new[] { typeof(object[]) }, true);
            //方法IL
            ILGenerator il = dynamicMethod.GetILGenerator();
            //实例化命令
            il.Emit(OpCodes.Newobj, constructor);
            //如果是值类型装箱
            if (constructor.ReflectedType.IsValueType)
                il.Emit(OpCodes.Box, constructor.ReflectedType);
            //返回
            il.Emit(OpCodes.Ret);
            //用FUNC去关联方法
            var func = (Func<Object>)dynamicMethod.CreateDelegate(typeof(Func<Object>));
            //执行方法
            return func.Invoke();
        }
    }
    //Emit的实现是抄自Ninject的实现方式。这里其实就是在手动书写IL。一个简单的书写IL的办法就是先用C#写好代码，然后用Reflector等反编译工具查看生成的IL，然后改成Emit代码。

    /// <summary>
    /// 实现IoCContainerManager
    /// </summary>
    public class IoCContainerManager
    {
        /// <summary>
        /// 容器
        /// </summary>
        private static IIoCContainer _container;

        /// <summary>
        /// 获取IOC容器
        /// </summary>
        /// <param name="config">ioc配置</param>
        /// <returns></returns>
        public static IIoCContainer GetIoCContainer(IIoCConfig config)
        {

            if (_container == null)
            {
                //反射方式
                _container = new ReflectionContainer(config);
                //EMIT方式
                // _container=new EmitContainer(config);
            }
            return _container;

        }
    }

    #endregion