白话系列之IOC,三个类实现简单的Ioc

前言:博客园上已经有很多IOC的博客.而且很多写的很好,达到开源的水平,但是对于很多新人来说,只了解ioc的概念,以及怎么去使用ioc.然后想更进一步去看源码,但是大部分源码都比较困难,当不知道一个框架整体时候,从每一个片段去推理,其实很耗费时间,所以这篇博客,从autofac及.netcore自带的ioc的源码中抽象出最核心代码,先了解整个ioc的实现方式,其他的所有好的ioc,只是在这个框架上面进行缝缝补补.

友情提示下,这个ioc虽然能够使用,但是只是为了做例子,所以只保留最核心代码,要使用还是使用autofac或成熟的ioc框架.

一:老生常谈

问:什么是ioc?

答:依赖注入,是一种思想,由于过分模糊,所以提出DI的观点:被注入对象依赖IOC容器配置依赖对象

问:有什么用?

答:解决高耦合问题,以前没有ioc的时候,每次都执行的是new操作,这没什么不好,但是假设,本来使用sqlserver,通过IConnection  conn = new Sqlserver();方式初始化所有的连接操作,但是现在老板要求改成mysql当做数据库,如果按照new的方式,得一个个去改,全局搜索,全局替换,其实也是可以的,无非是人累点,还需要一遍遍去检查,看哪里漏了,这时候就怀念Ioc的好处了,只需在容器内改变一处,便全局改变.当然,这里并不是少写了几行new代码,代码还是一样的多,只不过new的操作让容器去处理了.拟人化的方式就是,new的方式就相当于以前没群的时候,你本来是密令是10, 你一个个去通知你所想要通知的人即new,但是现在呢,密令被敌人偷听去了,你需要更改,这次改成20,你就得一个个通知,但是现在你每次联系别人都是通过手机去联系,你不需要管手机是怎么发送给对方的,只需要知道你给手机一个通知,其他人都可以立马收到,那么手机在这里扮演的就是容器的概念,一次更改,全部获悉

二:理论结束,开始思考准备ioc之前需要准备的东西

1.首先建立一个收集器,收集可能需要new的对象,那么会有几种生命周期去new一个对象?

常用的就是单例模式(singleton), 每次直接new对象,即用即抛(Transient),还有当前请求的主线程中只会创建一个对象(Scope,注意,单例是所有请求都会公用一个对象),所以,先定义接口,如下,命名即功能

    public interface IServiceCollection
    {
        IServiceCollection AddTransient<T1, T2>() where T2 : T1;
        IServiceCollection AddTransient<T1>(T1 t2);
        IServiceCollection AddSingleton<T1, T2>() where T2 : T1;
        IServiceCollection AddSingleton<T1>(T1 t2);
        IServiceCollection AddScoped<T1, T2>() where T2 : T1;
        IServiceCollection AddScoped<T1>(T1 t2);
        IServiceProvider BuildServiceProvider();
    }

2.其次,建立一个对象提供器,获取容器内的可以获取的对象

越简单越好,直接通过类型获取对应的对象,同样,接口定义如下:

    public interface IServiceProvider
    {
        T GetRequiredService<T>();
        Object GetRequiredService(Type type);
    }

3.Collection对收集的对象进行保存,并且需要对每个对象进行区分是Singleton,scoped,还是transient的

注意:我觉得在设计一个好的代码时候,得弄清楚当前类型具体的作用,然后如果作用不一样,那么得重新创建一个类型,当然如果后期发现没必要,可以合并,但是前期还是得分清楚点,就如sql中的范式及反范式.

3.1:首先定义枚举,区分当前的类型需要new的类型,与上文中的一致

    public enum ServiceLifetime
    {
        Singleton = ,
        Transient = ,
        Scoped =
    }

3.2:其次需要保存注入进去的类型及周期,因为不去考虑架构,只考虑那ioc的意思,就尽量简化代码

三:直接开始撸代码

1.通过Type创建对象,先默认只创建当前无参构造器,代码很简单

        public Object GetCache(IDictionary<Type, IServiceCache> typePairs)
        {
            if (_obj == null)
            {
                _obj = Activator.CreateInstance(_type);
            }
            switch (_typeEnum)
            {
                case ServiceLifetime.Transient:
                    return Activator.CreateInstance(_type);
                case ServiceLifetime.Singleton:
                    return _obj;
                case ServiceLifetime.Scoped:
                    throw new Exception("目前不支持scoped");
                default:
                    throw new Exception("请传递正确生命周期");
            }
        }

DeepClone的写法就是通过序列化的方式实现的,JsonConvert

      public static Object DeepClone(this Object obj, Type type)
        {
            return JsonConvert.DeserializeObject(JsonConvert.SerializeObject(obj), type);
        }

2.collection保存对应的对象,继承IServiceCollection接口

    public class ServiceCollection : IServiceCollection
    {
        private ConcurrentDictionary<Type, IServiceCache> _typePairs;
        public ServiceCollection()
        {
            _typePairs = new ConcurrentDictionary<Type, IServiceCache>();
        }
        public IServiceCollection AddScoped<T1, T2>() where T2 : T1{}
        public IServiceCollection AddScoped<T1>(T1 t2){}
        public IServiceCollection AddSingleton<T1, T2>() where T2 : T1{}
        public IServiceCollection AddTransient<T1, T2>() where T2 : T1{}
        public IServiceCollection AddSingleton<T>(T t2){}
        public IServiceProvider BuildServiceProvider(){}
    }

实现Singleton及Transient,此处Scoped有些额外的语法糖,等后期会猜想实现

       public IServiceCollection AddSingleton<T1, T2>() where T2 : T1
        {
            Type t1 = typeof(T1);
            Type t2 = typeof(T2);
            ServiceTypeCache service = new ServiceTypeCache(t2, ServiceLifetime.Singleton);
            if (!_typePairs.TryAdd(t1, service))
            {
                throw new Exception("在注入对象时,有相同对象存在");
            }
            return this;
        }
        public IServiceCollection AddTransient<T1, T2>() where T2 : T1
        {
            Type t1 = typeof(T1);
            Type t2 = typeof(T2);
            ServiceTypeCache service = new ServiceTypeCache(t2, ServiceLifetime.Transient);
            if (!_typePairs.TryAdd(t1, service))
            {
                throw new Exception("在注入对象时,有相同对象存在");
            }
            return this;
        }

3:实现IServiceProvider接口,就是从Cache中获取对应的对象

    public class ServiceProvider : IServiceProvider
    {
        private IDictionary<Type, IServiceCache> _cache;
        public ServiceProvider(IDictionary<Type, IServiceCache> valuePairs)
        {
            _cache = valuePairs;
        }
        public T GetRequiredService<T>()
        {
            Type t = typeof(T);
            return (T)GetRequiredService(t);
        }
        public object GetRequiredService(Type type)
        {
            IServiceCache service = null;
            if (!_cache.TryGetValue(type, out service))
            {
                throw new Exception("获取参数对象没有注入");
            }
            return service.GetCache();
        }
    }

4:将Collection转变为ServiceProvider

        public IServiceProvider BuildServiceProvider()
        {
            return new ServiceProvider(_typePairs);
        }

5:OK,现在来试试这种简单注入

    public interface ITestTransient
    {
        void Write();
    }
    public class TestATransient : ITestTransient
    {
        public void Write()
        {
            Console.WriteLine("----------------A----------------");
        }
    }
    public class TestBTransient : ITestTransient
    {
        public void Write()
        {
            Console.WriteLine("----------------B----------------");
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            InitA();
            InitB();
            Console.Read();
        }
        public static void InitA()
        {
            IServiceCollection collection = new ServiceCollection();
            collection.AddTransient<ITestTransient, TestATransient>();
            IServiceProvider provider =  collection.BuildServiceProvider();
            provider.GetRequiredService<ITestTransient>().Write();
        }
        public static void InitB()
        {
            IServiceCollection collection = new ServiceCollection();
            collection.AddTransient<ITestTransient, TestBTransient>();
            IServiceProvider provider = collection.BuildServiceProvider();
            provider.GetRequiredService<ITestTransient>().Write();
        }
    }

测试OK,只要在后面的代码中使用同一个provider,那么从IOC容器中获取的实例都是相同,改一处便全部都能修改

6.延伸,现在通过构造器注入其他代码,比如

class A{}
class B
{
   public B(A a) { }
}

猜想下,遇到这种构造器注入时候,怎么去处理,其实和创建Type对象一直,通过CreateInstance(Type, Object[] param);去创建,param是每个需要注入的类型对象

OK,那我们来改下代码,将获取Object对象的方法添加参数,因为构造器里面注入的参数都是从IOC里面获取

    public interface IServiceCache
    {
        Object GetCache(IDictionary<Type, IServiceCache> typePairs);
    }

获取当前Type类型的构造器,默认获取参数最多的,参数一样多的,获取最后一个,注:这里可以添加一个特性,标明优先构造这个构造器,自己添加就好,写法尽量简单

        private List<Type> GetConstructor()
        {
            ConstructorInfo[] a = _type.GetConstructors();
            ConstructorInfo b = null;
            Int32 length = ;
            foreach (ConstructorInfo info in a)
            {
                if (info.GetParameters().Length >= length)
                {
                    b = info;
                }
            }
            ParameterInfo[] pa = b.GetParameters();
            List<Type> list = new List<Type>();
            foreach (var p in pa)
            {
                list.Add(p.ParameterType);
            }
            return list;
        }

构造器参数,就需要从typePairs里面获取,注意,这里的所有参数都必须从IOC容器中获取,当然这里会有一个问题就是相互引用,这时候就需要注意下

        public Object GetCache(IDictionary<Type, IServiceCache> typePairs)
        {
            if (_obj == null)
            {
　　　　　　　　　　//这里实际是构建一个表达式树,这样就不需要每次去通过反射创建对象了
                List<Type> types = GetConstructor();
                Object[] paramters = types.ConvertAll(item => typePairs[item].GetCache(typePairs)).ToArray();
                _obj = Activator.CreateInstance(_type, paramters);
            }
            switch (_typeEnum){...}
        }

7.测试

    public class ConstructorIOCTest
    {
        private readonly ITestTransient m_test;
        public ConstructorIOCTest(ITestTransient test)
        {
            m_test = test;
        }
        public void WriteTestTransient()
        {
            m_test.Write();
            Console.WriteLine("--------------ConstructorIOCTest-----------");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            InitA();
            InitB();
            Console.Read();
        }
        public static void InitA()
        {
            IServiceCollection collection = new ServiceCollection();
            collection.AddTransient<ITestTransient, TestATransient>();
            collection.AddTransient<ConstructorIOCTest, ConstructorIOCTest>();
            IServiceProvider provider =  collection.BuildServiceProvider();
            provider.GetRequiredService<ConstructorIOCTest>().WriteTestTransient();
        }
        public static void InitB()
        {
            IServiceCollection collection = new ServiceCollection();
            collection.AddTransient<ITestTransient, TestBTransient>();
            collection.AddTransient<ConstructorIOCTest, ConstructorIOCTest>();
            IServiceProvider provider = collection.BuildServiceProvider();
            provider.GetRequiredService<ConstructorIOCTest>().WriteTestTransient();
        }
    }

可以看出来,所有的IOC都是从构造器出发,这样就避免到处修改的尴尬了

总结:

1.这是一个简单的IOC代码,里面我尽量采用最简单的小白的方式去实现,没有使用设计模式(本身最多有个工厂模式),没有表达式树,没有锁(锁是非常重要的,后期我会花几个章节去介绍各种锁)

2.IOC其实就是一个概念,理解之后,在构造的时候添加几个特性,比如属性注入,方法注入,其实无非就是在ServiceTypeCache类中添加构造器,方法,属性筛选之类的语法糖而已

3.这里没有时间Scopd的生命周期,因为我并不是很确定.net core中这个的写法,对我来说有2种,一种是在GetService时候,HttpContext注入,一种是将ServiceProvider里面进行包装一层Guid,相同的Guid的Scopd相同

4.希望大家可以去看看源码,尤其是推荐微软开源的几个框架,代码之精华,越看越觉得代码之美,虽然里面很多代码就是在打补丁,坑死人

5.https://github.com/BestHYC/IOCSolution.git,源码,代码的话我就不加工了,因为没什么好加工的,毕竟IOC实在太成熟了