依赖注入

定义：开发过程中，如果客户端程序依赖某个对象，我们常常对它进行一次抽象，形成抽象类，接口，这样客户端就可以摆脱锁依赖的具体类型。

其实也是里氏替换原则和依赖倒置原则

废话不说先看一个例子

public interface ITimeProvider
    {
        DateTime CurrentDate { get; }
    }
    public class TimeProvider : ITimeProvider
    {
        public DateTime CurrentDate { get { return DateTime.Now; } }
    }
    //客户端调用
    public class Client
    {
        public int GetYear()
        {
            ITimeProvider timeprovider = new TimeProvider();
            return timeprovider.CurrentDate.Year;
        }
    }

这个例子看似完美，也符合依赖抽象的原则，但是能不能再完美点，客户端不需要知道TimeProvider类型，就可直接调用他的类型呢，选择方式把ITimeProvider的实例传递给客户端程序，这个对象被称为Assembler 汇编

  //下面实现这个Assembler
    public class Assembler
    {
        static Dictionary<Type, Type> dictionary = new Dictionary<Type, Type>();
        static Assembler()
        {
            dictionary.Add(typeof(TimeProvider), typeof(TimeProvider));
        }

        public object Creat(Type type)
        {
            if ((type == null) || !dictionary.ContainsKey(type))
                throw new NullReferenceException();
            return Activator.CreateInstance(dictionary[type]);
        }

        //泛型方式调用
        public T Creat<T>()
        {
            return (T)Creat(typeof(T));
        }
    }

那么这样子客户端只需要知道接口和Assembler即可

看看客户端调用

   //客户端调用
    public class Client
    {
        public int GetYear()
        {
            ITimeProvider timeprovider = (new Assembler()).Creat<ITimeProvider>();
            return timeprovider.CurrentDate.Year;
        }
    }

这样子就达到更高层的抽象，使得客户端调用无需知道具体类型就可以实现实例，这种叫做依赖注入，注意Assembler不是依赖注入，他只是注入时候常用的一种手段

注入的三个角色

客户对象，Assembler，抽象类型 之中两个不能变，变的只有Assembler，它是负责组装的，如果注入过程还需要修改客户端，那么就违背的注入的原则