Unity 学习笔记(3) — 生命周期管理

426 views 四月 28, 09 by Timothy

Unity根据我们在注册类型的时候所指定的生命周期来管理注册类型的创建和解析。当我们在向容器中注册类型的时候，如果我们没有显式的指明该类型的生命周期管理器(下称:Lifetime Manager)，默认的情况下，容器会为我们注册的类型创建一个生命周期短暂的管理器。这样一来，当我们每次调用容器的Resolve方法或者ResolveAll方法，或者采用依赖机制注入实例到其他的类中的时候，容器都会为我们创建新的实例，并且容器不会保存对实例的引用。

容器的RegisterType函数包含多个支持泛型的重载，同时还包含了一一对应的非泛型重载。其中的重载函数，我们可以看到类似下面的声明：

   1:  RegisterType(LifetimeManager lifetime)

参数中的LifetimeManager类型，就是用来控制注册类型生命周期的。Unity中提供了几个继承自LifetimeManager的类作为注册类型的生命周期管理器。在目前的Unity 1.2版本中，共提供了3个LifetimeManager供我们直接在代码中调用。此外，我们也可以实现自己的LifetimeManager，不过必须实现LifetimeManager所必须的一些方法。

1.ContainerControlledLifetimeManager:

容器负责管理注册类型的生命周期，并且注册类型的生命周期和容器一致。当离开容器的作用域范围时，容器会被销毁，同时其中的注册类型也会被销毁。或者，当容器被显式销毁时，其中的注册类型也同样被销毁。但是在容器有效的作用域范围中，当我们使用Resolve方法，或者使用ResolveAll方法获取我们的注册类型的时候，容器会在第一次调用时，创建实例，但是在后面的调用中，我们始终只会得到相同的实例。我们可以利用这种Manager来实现Singleton模式。

2.ExternallyControlledLifetimeManager:

和上一种方式类似，不过容器在不会保留对注册类型的强引用，而只是保留弱引用。也就是说，如果这个注册类型没有在其他地方被强引用的时候，那么这个注册类型可能会被GC给干掉。

3.PerThreadLifetimeManager:

容器保证在每个线程中返回同一个对象实例，那么在不同的线程中，得到的实例是不同的。

下面我们可以试验一下不同的LifetimeManager的效果

a. 默认的情况，不显示的指明LifetimeManager

代码：

   1:  namespace UnityDemo
   2:  {
   3:      class Program
   4:      {
   5:          static void Main(string[] args)
   6:          {
   7:              IUnityContainer container = new UnityContainer();
   8:              container.RegisterType();
   9:  
  10:              INotify notify1 = container.Resolve();
  11:  
  12:              INotify notify2 = container.Resolve();
  13:  
  14:              Console.WriteLine("notify1:" + notify1.GetHashCode());
  15:              Console.WriteLine("notify2:" + notify2.GetHashCode());
  16:  
  17:              Console.ReadLine();
  18:          }
  19:      }
  20:  }

运行结果：

4

从结果我们可以看到，默认情况下不指定LifetimeManager的时候，每次我们获得的Instance其实不是同一个Instance.

b.使用ContainerControlledLifetimeManager

代码：

   1:  namespace UnityDemo
   2:  {
   3:      class Program
   4:      {
   5:          static void Main(string[] args)
   6:          {
   7:              IUnityContainer container = new UnityContainer();
   8:              container.RegisterType(new ContainerControlledLifetimeManager());
   9:  
  10:              INotify notify1 = container.Resolve();
  11:  
  12:              INotify notify2 = container.Resolve();
  13:  
  14:              Console.WriteLine("notify1:" + notify1.GetHashCode());
  15:              Console.WriteLine("notify2:" + notify2.GetHashCode());
  16:  
  17:              Console.ReadLine();
  18:          }
  19:      }
  20:  }

运行结果:

5
使用ContainerControlledLifetimeManager，在Container生命中期内，我们得到的Instance是同一个。

c.使用PerThreadLifetimeManager

代码：

   1:  namespace UnityDemo
   2:  {
   3:      class Program
   4:      {
   5:          static void Main(string[] args)
   6:          {
   7:              IUnityContainer container = new UnityContainer();
   8:              container.RegisterType(new PerThreadLifetimeManager());
   9:  
  10:              Thread thread1 = new Thread(new ParameterizedThreadStart(ThreadProc1));
  11:              Thread thread2 = new Thread(new ParameterizedThreadStart(ThreadProc2));
  12:  
  13:              thread1.Start(container);
  14:              thread2.Start(container);
  15:  
  16:              Console.ReadLine();
  17:          }
  18:  
  19:          static void ThreadProc1(object obj)
  20:          {
  21:              INotify notify1 = (obj as IUnityContainer).Resolve();
  22:              INotify notify2 = (obj as IUnityContainer).Resolve();
  23:  
  24:              Console.WriteLine("ThreadProc1 --- notify1:" + notify1.GetHashCode());
  25:              Console.WriteLine("ThreadProc1 --- notify2:" + notify2.GetHashCode());
  26:  
  27:          }
  28:  
  29:          static void ThreadProc2(object obj)
  30:          {
  31:              INotify notify1 = (obj as IUnityContainer).Resolve();
  32:              INotify notify2 = (obj as IUnityContainer).Resolve();
  33:  
  34:              Console.WriteLine("ThreadProc2 --- notify1:" + notify1.GetHashCode());
  35:              Console.WriteLine("ThreadProc2 --- notify2:" + notify2.GetHashCode());
  36:          }
  37:      }
  38:  }
运行结果：
6
 在结果中可以看到，同一个线程中连续两次获取到的是同一个Instance，而不同的线程中获取到的Instance不一样。

Unity 学习笔记(2) — 配置文件的使用

775 views 四月 25, 09 by Timothy

在Unity的配置中，使用配置文件也是一种非常灵活的方式，毕竟能够通过修改配置文件的文本就能达到改动的目的，而不需要对源码进行改动、重新编译。使用配置文件对Unity进行配置，需要增加两个程序集的引用：System.Configuration和Microsoft.Practices.Unity.Configration，并且在代码中用相应的两个命名空间：

   1:  using System.Configuration;
   2:  using Microsoft.Practices.Unity.Configuration;

此外，需要修改应用程序的配置文件：

在configSections节点中，加入Unity的section配置信息





...






type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration, Version=1.2.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>




<configSections>


...






type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration, Version=1.2.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>




其中name是section的名称，type就是处理该section的程序类型，Unity提供了UnityConfigurationSection，负责处理配置文件信息，它包含在程序集Microsoft.Practices.Unity.Configuration中

接下来，需要在configuration节点中增加Unity配置节点，格式如下：

   1:  
   2:      
   3:        "" type="" />
   4:      
   5:      
   6:        
   7:           
   8:             "" mapTo="" />
   9:           
  10:           
  11:             "" type="" value="" />
  12:           
  13:        
  14:      
  16:

unity的子元素，包含节点大致如上，其宗typeAliases是type别名，能够简化下面types中type的配置。containers节点中可以包含多个container的配置。container主要包含的子元素有types元素，instance元素，types元素可以包含多个type元素，用以添加注册类型，instance主要用来添加实例到容器中。type元素，主要包含四个属性：

name：表示注册类型的名称，此属性在配置中可选。

type:注册的源类型

mapto:注册的目标类型

lifetime:设置注册类型的生命周期

此外，还有instances元素，包括name,type,value,typeConverter四个属性。value表示注册实例的初始值，typeConverter是用以转换提供的值到实例的匹配类型的类型转换器。

具体的元素含义，可以参考Unity的帮助文档。

下面我们还是采用Monitor的例子，来实现用配置文件注册类型，配置文件示例：

   1:  "1.0" encoding="utf-8" ?>
   2:  
   3:    
   4:  

"unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />
   5:    
   6:  
   7:    
   8:      
   9:        
  10:          
  11:            "UnityDemo.IMonitor,UnityDemo" mapTo="UnityDemo.Monitor,UnityDemo" />
  12:            "UnityDemo.INotify,UnityDemo" mapTo="UnityDemo.EmailNotify,UnityDemo" />
  13:          
  14:        
  15:      
  16:    
  17:  
  18:

程序代码修改如下：

   1:  using System;
   2:  
   3:  using Microsoft.Practices.Unity;
   4:  using Microsoft.Practices.Unity.Configuration;
   5:  using System.Configuration;
   6:  
   7:  namespace UnityDemo
   8:  {
   9:      class Program
  10:      {
  11:          static void Main(string[] args)
  12:          {
  13:              IUnityContainer container = new UnityContainer();
  14:              UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
  15:              section.Containers.Default.Configure(container);
  16:  
  17:              IMonitor monitor = container.Resolve();
  18:              monitor.Alarm();
  19:  
  20:              Console.ReadLine();
  21:          }
  22:      }
  23:  }

编译运行结果：

使用配置文件，还有许多方便的地方，比如对于程序的扩展而言，新增的模块不再需要修改已编译好的程序，而只需要修改配置文件就可以方便的实现新模块的注册，对于系统的稳定性和可维护性都非常有好处。

Unity 学习笔记(1) — Unity简介及简单使用

556 views 四月 23, 09 by Timothy

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

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().
运行查看结果：
2
上面是针对单个构造函数的情况，如果有多个构造函数，需要指明哪个构造函数是需要被注入的,也即需要在指定被注入的构造函数加上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>();

运行查看结果：
3 还有一个比较方便的地方，可以为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");

运行查看结果：
2

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:          }

运行查看结果：

3