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

从Unity到Spring.Net,到Ninject,几年来陆陆续续用过几个IoC框架。虽然会用,但也没有一直仔细的研究过IoC实现的过程。最近花了点时间,下了Ninject的源码,研究了一番,颇有收获。下面我要实现一个最最简单的IoC容器,以让跟我一样的小菜能更好的理解IoC框架的到底为我们做了什么。

什么是IoC

IoC是英文Inversion of Control的缩写。我们一般叫它“控制反转”。IoC技术是用来解决面向对象设计一大原则依赖倒置而出现的技术。可以更好的实现面向接口编程,来使各个组件之间解耦。

IoC的实现原理

.NET IoC容器的一般就是两种,一是反射,二是使用Emit来直接写IL。

废话不多了,想要了解跟多的IoC的知识请Google。

关于实现

先上一张类图

1.定义IIoCConfig接口

  public interface IIoCConfig
    {
        void AddConfig<TInterface,TType>();

        Dictionary<Type, Type> ConfigDictionary { get; }
    }

2.定义IoCConfig实现

   public class IoCConfig:IIoCConfig
    {
        /// <summary>
        /// 存放配置的字典对象,KEY是接口类型,VALUE是实现接口的类型
        /// </summary>
        private Dictionary<Type, Type> _configDictionary=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("类型未实现接口");
            }
        }

        public Dictionary<Type, Type> ConfigDictionary
        {
            get
            {
                return _configDictionary;
            }
        }
    }

使用一个字典来保存Interface跟Class的对应关系。这里是仿造Ninject的配置方式,使用代码来配置。这种配置方式有个好处就是不会写错,因为有IDE来给你检查拼写错误。不要小看这个好处,当你有上百个注入对象的时候,使用Unity的XML来配置对应关系的时候很容易就会发生拼写错误。这种错误往往还很难发现。

当然这里要实现一个按照XML配置文件来设置对应关系的类也很容易,这里就不实现了。

3.定义IIoCContainer容器接口

public interface IIoCContainer
    {
        /// <summary>
        /// 根据接口返回对应的实例
        /// </summary>
        /// <typeparam name="TInterface"></typeparam>
        /// <returns></returns>
        TInterface Get<TInterface>();
    }

4.使用反射实现IoC容器

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("未找到对应的类型");
            }
        }
    }

反射这个代码太简单了,大家都会用。

5.使用Emit实现IoC容器

 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代码。

6.实现IoCContainerManager

 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;
            
        }
    }
代码太简单,不多说了。

7.使用

 public interface ITest
    {
        void DoWork();
    }

    public class Test:ITest
    {
        public void DoWork()
        {
           Console.WriteLine("do work!");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IIoCConfig config = new IoCConfig();
            config.AddConfig<ITest, Test>();//添加配置
            //获取容器
            IIoCContainer container = IoCContainerManager.GetIoCContainer(config);
            //根据ITest接口去获取对应的实例
            ITest test = container.Get<ITest>();

            test.DoWork();

            Console.Read();
        }
    }

输出:

这里手动使用IoC容器去获取对应的实例对象,我们也可以配合特性来使代码更加简单。这里就不实现了。

8.总结

通过这么短短的几行代码。我们实现了一个最最简单的IoC容器。它可以实现构造函数注入(默认无参)。但是这就已经揭示了IoC框架最本质的东西:反射或者EMIT来实例化对象。然后我们可以加上缓存,或者一些策略来控制对象的生命周期,比如是否是单例对象还是每次都生成一个新的对象。

 源码

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏菩提树下的杨过

dubbo/dubbox 增加原生thrift及avro支持

(facebook) thrift / (hadoop) avro / (google) probuf(grpc)是近几年来比较抢眼的高效序列化/rpc框架,d...

3568
来自专栏跟着阿笨一起玩NET

以读取博客园随笔备份为例 将xml 序列化成json,再序列化成对象

资源下载:http://files.cnblogs.com/codealone/ConsoleApplication2.zip

651
来自专栏java思维导图

自己手写一个 SpringMVC 框架

前端框架很多,但没有一个框架称霸,后端框架现在Spring已经完成大一统.所以学习Spring是Java程序员的必修课. Spring 框架对于 Java 后端...

4016
来自专栏别先生

前后台交互经常使用的技术汇总(后台:Java技术,前台:Js或者Jquery)

1:由于针对特定的前后台交互用到的知识总结,所以不大量贴代码,主要给出思路,方便自己以后脑补和技术总结,当然也希望可以帮助到别人。 后台Json和其他格式转化,...

4928
来自专栏DT乱“码”

Memcached使用实例

package com.memcached.util; import java.io.BufferedWriter; import java.io.FileW...

2086
来自专栏菩提树下的杨过

spring mvc4:异常处理

前面学习过struts2的异常处理,今天来看下spring mvc4的异常处理: 一、Servlet配置文件修改 1 <bean id="excepti...

2075
来自专栏后端之路

Dubbo之telnet实现

我们可以通过telnet来访问道对应dubbo服务的信息 比如 ? 我们可以利用一些指令来访问。 我们知道,默认情况下,dubbo使用netty做transpo...

4119
来自专栏JAVA高级架构

自己手写一个 SpringMVC 框架

前端框架很多,但没有一个框架称霸,后端框架现在Spring已经完成大一统.所以学习Spring是Java程序员的必修课. Spring 框架对于 Java 后...

33510
来自专栏张高兴的博客

张高兴的 Windows 10 IoT 开发笔记:使用 MAX7219 驱动数码管

3485
来自专栏cmazxiaoma的架构师之路

通用Mapper和PageHelper插件 学习笔记

6913

扫码关注云+社区