Microsoft.Practices.Unity入门

Unity是微软Patterns & Practices团队所开发的一个轻量级的，而且可扩展的依赖注入(Dependency Injection)容器，它支持经常使用的三种依赖注入方式：构造器注入(Constructor Injection)、属性注入(Property Injection)，以及方法调用注入(Method Call Injection).如今Unity最新的版本的1.2版，能够在微软的开源站点http://unity.codeplex.com下载最新的发布版本和文档。经过使用Unity，咱们能轻松构建松耦合结构的程序，从而让整个程序框架变得清晰和易于维护。

在日常的软件编码过程当中，程序的逻辑每每很复杂，尤为是大型项目的开发中，一个模块经常会去引用其余的模块，假设咱们有一个监控器类，用来监控CPU的温度，当温度达到预警的范围时，监控器有一个报警的方法，方法里面经过短信提醒器，以发送短信的方式通知维护人员。因而就出现了下面这样一段最为常见的代码：

   1:  public class Monitor

   2:  {

   3:         public void Alarm()

   4:         {

   5:                 SMSNotify notify = new SMSNotify();

   6:                 notify.Send();

   7:          }

   8:  }

在Monitor类中，直接引用到了一个短信提醒器的类，这是最为不灵活和最不易于扩展的一种方式。或许咱们想到了面向接口编程，利用多态的好处，能够提供灵活的不一样子类的实现，增长代码扩展性等等。可是说到底，接口必定是须要实现的，也就是以下语句早晚要执行：

   1:  public void Alarm()

   2:  {

   3:         INotify notify = new SMSNotify();

   4:         notify.Send();

   5:  }

这样看来，在实现INotify这个接口的时候，仍然须要具体的类来实现，而这样的代码在程序编译的时候就已经固定下来，若是之后须要使用新的提醒器，仍旧须要修改源代码并从新编译。而且在咱们的Monitor类中，明显依赖SMSNotify类，两者之间的耦合度很是紧密。所以Ioc(控制反转)模式被提出用来解决这种问题，也即把接口的具体实现延缓到运行时，接口的实现类是在运行时被装载的。这样，就算有了新的实现类，也不须要更改调用者的代码(能够在Unity中使用配置文件的方式实现)。这种Ioc模式能够被形象的比喻为：接口就像一个空壳，而在具体实现时，向这个空壳注入内容，而让它成为一个真正的实体。这种模式也被形象的称为：依赖注入。经过使用Unity，咱们能构建松耦合的软件，而且对象之间相互关联的细节，咱们也没必要关心，能够交由依赖注入容器全权负责。

前面也提到了依赖注入经常使用的三种形式：构造器注入、属性注入和方法调用注入，咱们能够经过例子来实现这三种形式的注入。仍是以上面的场景为例：

 

1.Constructor Injection

IMonitor接口定义：

   1:  public interface IMonitor

   2:  {

   3:      void Alarm();

   4:  }

Monitor类：

   1:  public class Monitor : IMonitor

   2:  {

   3:      private INotify notify;

   4:  

   5:      public Monitor(INotify n)

   6:      {

   7:          notify = n;

   8:      }

   9:  

  10:      public void Alarm()

  11:      {

  12:          notify.Send();

  13:      }

  14:  }

INotify接口定义：

   1:  public interface INotify

   2:  {

   3:      void Send();

   4:  }

EmailNotify类：

   1:  public class EmailNotify : INotify

   2:  {

   3:      public void Send()

   4:      {

   5:          Console.WriteLine("Send Email Notify...");

   6:      }

   7:  }

SMSNotify类：

   1:  public class SMSNotify : INotify

   2:  {

   3:      public void Send()

   4:      {

   5:          Console.WriteLine("Send SMS Notify...");

   6:      }

   7:  }

能够看到，在Monitor类的构造函数里面，传入的参数是一个INotify接口类型，Alarm方法，调用了实现类的Send方法，但具体调用哪个实现类的Send方法，只有在注入实体后才知道。Unity容器中，一般使用RegisterType和Resolve方法来分别注册和获取实例，而且这两个方法有不少泛型和非泛型的重载，具体的类型和参数，能够参考Unity的官方帮助文档。

如今咱们向Monitor的构造函数注入实现INotify接口的实例:

   1:  static void Main(string[] args)

   2:  {

   3:      IUnityContainer container = new UnityContainer();

   4:      container.RegisterType<IMonitor, Monitor>().RegisterType<INotify, SMSNotify>();

   5:  

   6:      IMonitor monitor = container.Resolve<IMonitor>();

   7:      monitor.Alarm();

   8:  

   9:      Console.ReadLine();

  10:  }

代码中咱们注入的INotify实例是SMSNotify类的实例，而后调用monitor.Alrarm()，里面会调用notify.Send().
上面是针对单个构造函数的状况，若是有多个构造函数，须要指明哪一个构造函数是须要被注入的,也即须要在指定被注入的构造函数加上attribute:InjectionConstructor

   1:  public Monitor(INotify n, string name)

   2:  {

   3:      notify = n;

   4:  }

   5:  

   6:  [InjectionConstructor]

   7:  public Monitor(INotify n)

   8:  {

   9:      notify = n;

  10:  }

运行后可获得同样的结果.

2.Property Injection

经过属性注入，咱们须要加上attribute: Dependency，使得Unity容器在获取类对象实例时，自动实例化该属性所依赖的对象，并注入到属性中。

修改Monitor类,实现下面的代码：

   1:  public class Monitor : IMonitor

   2:  {

   3:      [Dependency]

   4:      public INotify Notify { get; set; }

   5:  

   6:      public void Alarm()

   7:      {

   8:          Notify.Send();

   9:      }

  10:  }

再在Main函数里面，修改原有的代码，此次咱们让容器注入EmailNotify实例：

   1:  container.RegisterType<INotify, EmailNotify>();

 还有一个比较方便的地方，能够为Dependency特性指定名称，这样，在注入时，会将RegisterType所指定的对应名称的实体进行注入，例如：

   1:      public class Monitor : IMonitor

   2:      {

   3:          [Dependency("SMS")]

   4:          public INotify Notify { get; set; }

   5:  

   6:          public void Alarm()

   7:          {

   8:              Notify.Send();

   9:          }

  10:      }

修改Main函数，在RegisterType函数中指定注入名称:

   1:              container.RegisterType<INotify, EmailNotify>("Email");

   2:              container.RegisterType<INotify, SMSNotify>("SMS");

 

3.Method Call Injection

Method Call Injection注入的时机和Constructor Injection有必定的区别，构造函数注入，是在容器建立实例的时候，而方法调用注入，是在方法被调用的时候。实现方法调用注入，须要在指定注入的方法前加上attribute: InjectionMethod

修改Monitor类的代码以下：

   1:      public class Monitor : IMonitor

   2:      {

   3:          private INotify notify;

   4:  

   5:          [InjectionMethod]

   6:          public void GetNotify(INotify n)

   7:          {

   8:              notify = n;

   9:          }

  10:  

  11:          public void Alarm()

  12:          {

  13:              notify.Send();

  14:          }

  15:      }

在程序运行时，容器会自动实例化GetNotify方法所依赖的对象，并自动调用该方法，将其注入到方法中。

Main函数以下：

   1:          static void Main(string[] args)

   2:          {

   3:              IUnityContainer container = new UnityContainer();

   4:              container.RegisterType<IMonitor, Monitor>();

   5:              container.RegisterType<INotify, EmailNotify>();

   6:  

   7:              IMonitor monitor = container.Resolve<IMonitor>();

   8:              monitor.Alarm();

   9:  

  10:              Console.ReadLine();

  11:          }
摘自(http://www.lywill.com/archives/kf/2013/Microsoft-Practices-UnityRuMen/)