Unity 使用快速教程

Unity是微软在CodePlex上的一个开源项目，可用于依赖注入、控制反转，类似Spring，下面是使用示例：

1.先来定义几个接口、类

 namespace UnityTest
 {
     public interface IRun
     {
         void Run();
     }
 }

: IRun

 namespace UnityTest
 {
     public class Pet
     {
         public string Name { set; get; }
     }
 }

: Pet

 using System;

 namespace UnityTest
 {
     public class Cat : Pet, IRun
     {
         public void Run()
         {
             Console.WriteLine("A cat is runing...");
         }
     }
 }

: Cat

 using System;

 namespace UnityTest
 {
     public class Dog : Pet, IRun
     {
         public void Run()
         {
             Console.WriteLine("A dog is runing...");
         }
     }
 }

: Dog

 namespace UnityTest.Model
 {
     public class Person
     {
         IRun iRun;

         public Person(IRun iRun)
         {
             this.iRun = iRun;
         }

         public void HiWeGo()
         {
             iRun.Run();
         }
     }
 }

:Person

2、创建对象实例

 using System;
 using System.Web.Script.Serialization;
 using Microsoft.Practices.Unity;

 namespace UnityTest
 {
     class Program
     {
         static void Main(string[] args)
         {
             var container = new UnityContainer();
             container.RegisterType<IRun, Dog>(); //注册类型，并将IRun映射到Dog
             var dog1 = container.Resolve<IRun>(); //创建一个IRun实例，实际上就是Dog
             (dog1 as Dog).Name = "buddy";
             Console.WriteLine("a dog is born，his name is \"{0}\"", (dog1 as Dog).Name); //a dog is born，his name is "buddy"
             Console.Read();
         }
     }
 }

3、使用标识符

当IRun同时有多个实例类要注入时，如果没有标识来区别，创建出来的实例“类型”就没办法显示指定。

             var container = new UnityContainer();
             container.RegisterType<IRun, Dog>()
                     .RegisterType<IRun, Cat>();
             var run = container.Resolve<IRun>();//这里的run实例，是cat，还是dog ?
             Console.Write(run.ToString());//UnityTest.Cat

             var container = new UnityContainer();
             container.RegisterType<IRun, Dog>("dogType")
                     .RegisterType<IRun, Cat>("catType");
             var run = container.Resolve<IRun>("dogType");//明确指示，我要一个dog
             Console.Write(run.ToString());//UnityTest.Dog

4、创建单例

             var container = new UnityContainer();
             container.RegisterType<IRun, Dog>("dogTypeSingle", new ContainerControlledLifetimeManager())//dogTypeSingle为单例模式
                     .RegisterType<IRun, Dog>("dogType");

             var dog1 = container.Resolve<IRun>("dogTypeSingle");
             var dog2 = container.Resolve<IRun>("dogTypeSingle");

             Console.WriteLine(object.ReferenceEquals(dog1, dog2));//True
             Console.WriteLine(dog1.GetHashCode() == dog2.GetHashCode());//True 说明dog1与dog2是同一个对象

             var dog3 = container.Resolve<IRun>("dogType");
             var dog4 = container.Resolve<IRun>("dogType");
             Console.WriteLine(object.ReferenceEquals(dog3, dog4));//False
             Console.WriteLine(dog3.GetHashCode() == dog4.GetHashCode());//False 说明dog3与dog4是不同的对象

：Singleton

5、依赖注入

构造器自动注入

             var container = new UnityContainer();
             container.RegisterType<IRun, Dog>();
             var personWithDog = container.Resolve<Person>();
             personWithDog.HiWeGo();//A dog is runing...

构造器也可以结合标识符显示注入

             var container = new UnityContainer();
             container.RegisterType<IRun, Dog>("dog")
                 .RegisterType<IRun, Cat>("cat")
                 .RegisterType<Person, Person>("PersonWithDog", new InjectionConstructor(container.Resolve<IRun>("dog")))
                 .RegisterType<Person, Person>("PersonWithCat", new InjectionConstructor(container.Resolve<IRun>("cat")));

             var personWithDog = container.Resolve<Person>("PersonWithDog");
             personWithDog.HiWeGo();//A dog is runing...
             var personWithCat = container.Resolve<Person>("PersonWithCat");
             personWithCat.HiWeGo();//A cat is runing...
             Console.Read();

使用InjectionConstructor特性注入

为了演示[InjectionConstructor]特性，先改造一下Person类

 using System.Collections.Generic;
 using Microsoft.Practices.Unity;
 namespace UnityTest
 {
     public class Person
     {
         private List<IRun> pets;

         public Person()
         {
             pets = new List<IRun>();
         }

         [InjectionConstructor]
         public Person(IRun iRun):this()
         {
             pets.Add(iRun);
         }

         public Person(IRun iRun1,IRun iRun2):this()
         {
             pets.Add(iRun1);
             pets.Add(iRun2);
         }

         public void HiWeGo()
         {
             foreach (var pet in pets)
             {
                 pet.Run();
             }
         }
     }
 }

测试一下：

             var container = new UnityContainer();

             container.RegisterType<IRun, Dog>("dog") //注册一个带标识的dog类型
                 .RegisterType<IRun, Cat>("cat") //注册一个带标识的cat类型
                 .RegisterType<IRun, Dog>() //不指定标识，即默认IRun的实例为dog
                 .RegisterType<Person, Person>("PersonWithDogAndCat",
                     new InjectionConstructor(
                         container.Resolve<IRun>("dog"),
                         container.Resolve<IRun>("cat")
                     )//显示将二个参数的构造方法注册到容器中
                 );

             var person = container.Resolve<Person>();//自动调用有InjectionConstructor标记的构造方法
             person.HiWeGo();//A dog is runing...

             Console.WriteLine("---------------");

             var personWithDogAndCat = container.Resolve<Person>("PersonWithDogAndCat");//显式调用在容器中注册过的构造方法
             personWithDogAndCat.HiWeGo();
             //A dog is runing...
             //A cat is runing...

             Console.Read();

未完待续...