01-Unity深入浅出(一)

一. 温故而知新

　　在开始学习Unity框架之前，有必要温习一下 【依赖倒置原则】和【手写IOC】, 因为我们框架代码的构建都是基于【依赖倒置原则】的，而Unity框架的核心思想就是IOC和DI，所以有必要了解通过【反射+工厂+配置文件】来实现手写IOC的原理。

　　废不多说，简单提炼一下依赖原则的核心理念：面向接口编程。上层（UI层）不直接依赖于下层，而是依赖于下层对应的接口，下层去实现该接口。

　　经典案例：业务层连接数据库，依赖接口，可以实现不改代码轻松切换数据库的目的。

　　手动创建对象的三个阶段：直接new实例化→面向接口编程→将创建对象的交给工厂【手写IOC】。

   　　　　　　#region 手动创建对象几个阶段
             {
                 Console.WriteLine("--------------一.复习依赖倒置原则和手写IOC（简单工厂+反射+配置文件）----------------");
                 //1. 直接创建(需要添加对Service层的引用)
                 Console.WriteLine("--------------1. 直接创建----------------");
                 AndroidPhone androidPhone1 = new AndroidPhone();
                 androidPhone1.Call();

                 //2. 利用接口进行改造(需要添加对Service和Interface层的引用)
                 Console.WriteLine("--------------2. 利用接口进行改造----------------");
                 IPhone androidPhone2 = new AndroidPhone();
                 androidPhone2.Call();

                 //3. 手写IOC(只需要添加Interface层的引用,但需要把Service层生成的DLL拷贝到该项目bin下)
                 Console.WriteLine("--------------3. 利用接口进行改造----------------");
                 IPhone androidPhone3 = ObjectFactory.CreateObject<IPhone>();
                 androidPhone3.Call();

                 //总结：第三个阶段基本上已经是我们自己写容器的最高层次
                 //下面我们将借助微软的第三方容器Unity来创建

             }
             #endregion

依赖倒置原则详见：http://www.cnblogs.com/yaopengfei/p/7101347.html

手写IOC详见：http://www.cnblogs.com/yaopengfei/p/6891286.html

二. Unity深入浅出

(一). Unity介绍

 1. Unity的获取方式

　  ①：下载网址：http://unity.codeplex.com/

②：通过Nuget获取  （目前最新版本为4.0.1）

2. Unity是什么？

　　Unity是一个IOC容器，用它可以来创建对象，代替手写反射，它可以实现依赖注入(DI)，它出自于微软。.Net平台下类似的其它IOC框架还有：Spring.Net、AutoFac、Castle等等。

3. IOC的含义

　　IOC是一种目标，IOC的含义为控制反转，即原本上端（UI层）直接创建或使用的对象，交给第三方容器来装配和创建。

4.  DI的含义

     DI是一种手段，DI的含义为依赖注入，Unity提供三种方式分别是：属性注入、方法注入、构造函数注入。

(二). 使用Unity来创建对象

 1. 创建对象的步骤

　　①：声明IUnityContainer容器。

　　②：通过RegisterType注册新类型 或者 通过RegisterInstance注册已经存在的类型。

　　③：通过Resove解析对象。

特别注意：注册类型时，可以指定名称来注册，用于同时创建注册多个类型时，Resove可以通过指定的注册名称来针对指定解析。

 2.  代码说明

   ①：代码结构（后面所有的代码说明都是基于这个结构的）

　详细说明：各个类的内容待写。

　②：直接创建简单对象（需要添加对Interface层和Service层的引用）

  {
                 Console.WriteLine("-------------------  二. Unity入门  -------------------");
                 Console.WriteLine("-------------------  01-直接创建对象  -------------------");
                 IUnityContainer container = new UnityContainer();
                 //进行注册，可以是：  接口-类、父类-子类、抽象类-子类。
                 //container.RegisterType<IPhone, AndroidPhone>();
                 //也可以用实例注册已经存在的对象
                 AndroidPhone android = new AndroidPhone();
                 container.RegisterInstance<IPhone>(android);
                 //解析对象
                 IPhone phone = container.Resolve<IPhone>();
                 phone.Call();
                 //我们会发现，虽然注册了AndroidPhone对象，但是该对象中的三个属性并没有实例化，依旧为空
                 Console.WriteLine("phone.iHeadphone==null? {0}", phone.iHeadphone == null);
                 Console.WriteLine("phone.iMicrophone==null? {0}", phone.iMicrophone == null);
                 Console.WriteLine("phone.iPower==null? {0}", phone.iPower == null);
  }

　详解：上述代码我们分别通过RegisterType注册类型、RegisterInstance注册已经存在的类型，我们会发现最终生成AndoridPhone中的三个属性并没有被实例化，那么怎么实例化里面的属性呢？这就涉及到后面的依赖注入了。

　③. 指定命名来创建对象（需要添加对Interface层和Service层的引用）

    {
                 Console.WriteLine("-------------------  03-同时创建多个对象  -------------------");
                 //可以通过添加一个参数来区分
                 IUnityContainer container = new UnityContainer();
                 //注册类型时（指定命名）
                 container.RegisterType<IPhone, AndroidPhone>();
                 container.RegisterType<IPhone, ApplePhone>("apple");
                 container.RegisterType<IPhone, AndroidPhone>("android");
                 //依赖注入
                 container.RegisterType<IMicrophone, Microphone>();
                 container.RegisterType<IHeadphone, Headphone>();
                 container.RegisterType<IPower, Power>();
                 //解析对象
                 IPhone iphone1 = container.Resolve<IPhone>();
                 iphone1.Call();
                 //解析对象（指定命名）
                 IPhone iphone2 = container.Resolve<IPhone>("apple");
                 iphone2.Call();
                 IPhone iphone3 = container.Resolve<IPhone>("android");
                 iphone3.Call();

                 //获取所有已注册且指定命名的对象（未指定命名的不能获取）
                 var list = container.ResolveAll<IPhone>();

  }

　　详解：注册类型时，如果默认不指定命名，则后面的会覆盖前面的，解析多个对象时，永远是最后一个注册的类型的对象。  所以RegisterType指定命名 、Resolve解析对象指定命名广泛用于同时创建多个对象的情况。

　　我们发现上述代码有三句是依赖注入的，这个在下面讲解。

(三). 依赖注入的三种形式

　　Unity实现依赖注入有三种形式，分别是构造函数注入、属性注入、方法注入，分别对应三个特性：【InjectionConstructor】、【Dependency】、【InjectionMethod】，加上这三个特性表明构造函数中、属性中、方法中需要注入对象，使其实例化。

　　方式一：属性注入。

　　有WinPhone1类，实现了Iphone接口。其中WinPhone1类中的iMicrophone和iHeadphone两个属性上分别添加【Dependency】和【Dependency("fk")】，表明该属性对应的对象需要注入，其中iHeadphone需要Unity容器"指定命名"来注册类型。

  public interface IPhone
     {
         void Call();
         IMicrophone iMicrophone { get; set; }

         IHeadphone iHeadphone { get; set; }

         IPower iPower { get; set; }
     }

    /// <summary>
     /// 测试属性注入的类
     /// </summary>
     public class WinPhone1 : IPhone
     {
         [Dependency("fk")]   //表示该属性需要注入,且需要指定名称
         public IMicrophone iMicrophone { get; set; }
         [Dependency]   //表示该属性需要注入
         public IHeadphone iHeadphone { get; set; }
         public IPower iPower { get; set; }

         public WinPhone1()
         {
             Console.WriteLine("{0}被构造", this.GetType().Name);
         }

         public void Call()
         {
             Console.WriteLine("{0}打电话", this.GetType().Name); ;
         }
     }

                IUnityContainer container = new UnityContainer();
                 //方式一： 属性注入
                 Console.WriteLine("----------------------------方式一： 属性注入 -------------------------------");
                 container.RegisterType<IPhone, WinPhone1>();
                 //指定命名注入
                 container.RegisterType<IMicrophone, Microphone>("fk");
                 //普通注入
                 container.RegisterType<IHeadphone, Headphone>();
                 IPhone phone1 = container.Resolve<IPhone>();
                 phone1.Call();                

补充说明：我们发现Microphone和HeadPhone均被构造，说明这两个类被注入成功。

　　方式二：方法注入。

　　有WinPhone2类，实现了Iphone接口。其中在WinPhone2中的方法Init1234方法上加【InjectionMethod】特性，表示该方法中有对象需要注入。

 　　 public class WinPhone2:IPhone
     {
         public IMicrophone iMicrophone { get; set; }
         public IHeadphone iHeadphone { get; set; }
         public IPower iPower { get; set; }

         public WinPhone2()
         {
             Console.WriteLine("{0}被构造", this.GetType().Name);
         }

         public void Call()
         {
             Console.WriteLine("{0}打电话", this.GetType().Name); ;
         }

         [InjectionMethod]   //方法注入,表明该方法中有对象需要注入
         public void Init1234(IPower power)
         {
             this.iPower = power;
         }
     }

        //方式二：方法注入
        Console.WriteLine("----------------------------方式二：方法注入 -------------------------------");
        container.RegisterType<IPhone, WinPhone2>();
        container.RegisterType<IPower, Power>();
        IPhone phone2 = container.Resolve<IPhone>();
        phone2.Call();            

补充说明：我们发现Power被构造，说明该类被注入成功。

　　方式三：构造函数注入(又分四种情况）

　　A.  默认注入。 自动识别参数数量最多的构造函数，表示该构造函数中有对象需要注入。

　　B. 指定构造函数。通过在构造函数上加 [InjectionConstructor]特性，表示该构造函数中有对象需要注入。

　　C. 指定构造函数且指定注入参数的名称。通过在构造函数上加 [InjectionConstructor]特性，并且在参数上加 [Dependency("fk")] ，表示该构造函数中的该参数中的对象需要注入。

　　D. 指定构造函数且指定注入参数的值（了解即可）。

     /// <summary>
     /// 测试构造函数注入（默认方式）
     /// </summary>
     public class WinPhone3 : IPhone
     {
         public IMicrophone iMicrophone { get; set; }
         public IHeadphone iHeadphone { get; set; }
         public IPower iPower { get; set; }

         public WinPhone3(IPower iPower)
         {
             Console.WriteLine("{0}被构造", this.GetType().Name);
         }

         public void Call()
         {
             Console.WriteLine("{0}打电话", this.GetType().Name); ;
         }

     }

     /// <summary>
     /// 测试构造函数注入（指定构造函数）
     /// </summary>
     public class WinPhone4 : IPhone
     {
         public IMicrophone iMicrophone { get; set; }
         public IHeadphone iHeadphone { get; set; }
         public IPower iPower { get; set; }
         public WinPhone4()
         {

         }
         [InjectionConstructor]   //指定该构造函数需要被注入
         public WinPhone4(IPower iPower)
         {
             Console.WriteLine("{0}被构造", this.GetType().Name);
         }

         public void Call()
         {
             Console.WriteLine("{0}打电话", this.GetType().Name); ;
         }

     }

     /// <summary>
     /// 测试构造函数注入（指定参数依赖的注册名称）
     /// </summary>
     public class WinPhone5 : IPhone
     {
         public IMicrophone iMicrophone { get; set; }
         public IHeadphone iHeadphone { get; set; }
         public IPower iPower { get; set; }
         public WinPhone5()
         {

         }
         [InjectionConstructor]   //指定该构造函数需要被注入且指定注入参数的名称
         public WinPhone5([Dependency("fk")]IPower iPower)
         {
             Console.WriteLine("{0}被构造", this.GetType().Name);
         }

         public void Call()
         {
             Console.WriteLine("{0}打电话", this.GetType().Name); ;
         }

     }

   /// <summary>
    /// 测试构造函数注入（指定参数值）
    /// </summary>
    public class WinPhone6 : IPhone
    {
        public IMicrophone iMicrophone { get; set; }
        public IHeadphone iHeadphone { get; set; }
        public IPower iPower { get; set; }
        public WinPhone6()
        {

        }
        [InjectionConstructor]   //指定该构造函数需要被注入且指定注入参数的值
        public WinPhone6(IPower iPower,string name)
        {
            Console.WriteLine("{0}被构造", this.GetType().Name);
        }

        public void Call()
        {
            Console.WriteLine("{0}打电话", this.GetType().Name); ;
        }

    }

                  //方式三：构造函数注入（又分4中情况）
                 /*
                  A. 默认方式
                  B. 指定构造函数
                  C. 指定参数依赖的注册名称
                  D. 指定参数值
                  */
                 Console.WriteLine("-----------------------方式三：构造函数注入（又分4中情况）----------------------------");
                 //A. 默认注入参数最多的构造函数
                 {
                     Console.WriteLine("-----------------------A. 默认注入参数最多的构造函数----------------------------");
                     container.RegisterType<IPhone, WinPhone3>();
                     container.RegisterType<IPower, Power>();
                     IPhone iphone = container.Resolve<IPhone>();
                     iphone.Call();
                 }
                 //B. 指定构造函数
                 {
                     Console.WriteLine("-----------------------B. 指定构造函数----------------------------");
                     container.RegisterType<IPhone, WinPhone4>();
                     container.RegisterType<IPower, Power>();
                     IPhone iphone = container.Resolve<IPhone>();
                     iphone.Call();
                 }
                 //C. 指定参数依赖的注册名称
                 {
                     Console.WriteLine("-----------------------C. 指定参数依赖的注册名称----------------------------");
                     container.RegisterType<IPhone, WinPhone5>();
                     container.RegisterType<IPower, Power>("fk");
                     IPhone iphone = container.Resolve<IPhone>();
                     iphone.Call();
                 }
                 //D．指定参数值(了解即可)
                 {
                     Console.WriteLine("-----------------------D．指定参数值(了解即可)----------------------------");
                     container.RegisterType<IPhone, WinPhone6>(new InjectionConstructor(new Power() { }, "ypf"));
                     IPhone iphone = container.Resolve<IPhone>();
                     iphone.Call();
                 }

　　小结一下： 以上内容分别介绍了IOC和DI的概念、Unity的使用方式和创建对象的方式、DI的三种注入方式。细心的人或者有经验的人一定会发现，上述代码依旧需要添加对Service层和Interface层的引用，那么用Unity有什么用？使用了Untiy来创建对象有何好处呢？

　　我们自己手写IOC的方式（反射+工厂+配置文件）的方式已经可以脱离对Service层的直接引用了，怎么引入Unity反而又需要添加对Service层的引用呢？这不是徒增烦恼么？

　　下面我们来解惑：上述所有代码（包括Unity步骤的三步走）都是在代码层次上，介绍Unity的基本API的使用，方便我们大家明白Unity有哪些功能，但在实际开发中，Unity三步走中的第二步，注册类型是通过配置文件来注册的，创建Unity容器和解析类型是通过代码来实现的→→这样就可以达到 脱离Service层的引用了（只需要把Service层的dll复制到主程序的bin文件下即可）。

　　有的人还会发现：即使使用了配置文件最多也就是和手写iOC打了个平手，并没有看到Unity特有的好处，我们下个章节将介绍的Unity的声明周期，即是Unity特有的一些封装，就可以见识到Unity的强大。