[IOC]Unity使用

unity是patterns&practices团队开发的一个轻量级、可扩展的依赖注入容器。

1、它提供了创建（或者装配）对象实例的机制，而这些对象实例可能还包含了其它被依赖的对象实例。

2、Unity允许将预先配置的对象注入到类中，实现了inversion of control（Ioc）的功能。在Unity中，支持constructor injection（构造器注入），property setter injection（属性设置值注入）和method call injection（方法注入）。

3、支持容器的体系结构。一个容器可以有子容器，允许从子容器到父容器的对象定位查询。

4、可以通过配置文件进行准备和配置容器。

5、不会影响到类的定义（属性设置值注入和方法注入除外），这也是轻量级容器的一个体现。

6、支持自定义的容器扩展。

新建一个控制台程序，Nuget安装Unity

新建一个叫IFlyable 飞行能力的接口。

    /// 
    /// 飞行接口    /// 
    public interface IFlyable    {        void Fly();    }

一个飞禽类，并实现飞行的接口

    /// 
    /// 飞禽类    /// 
    public class Bird : IFlyable    {        public void Fly()        {            Console.WriteLine("会飞的鸟......");        }    }

在Main方法中，通过Unity容器实例化一个飞禽对象，并让它飞。

        static void Main(string[] args)        {            IUnityContainer container = new UnityContainer();            //注入            container.RegisterType();            IFlyable bird = container.Resolve();            bird.Fly();            Console.Read();        }

输出

 如果多个实现类呢？

添加个飞机类，让其实现飞行接口

    /// 
    /// 飞机    /// 
    public class Plane : IFlyable    {        public void Fly()        {            Console.WriteLine("超音速飞行......");        }    }

main方法

        static void Main(string[] args)        {            IUnityContainer container = new UnityContainer();            //注入            container.RegisterType();            container.RegisterType();            IFlyable bird = container.Resolve();            IFlyable plane = container.Resolve();            bird.Fly();            plane.Fly();            Console.Read();        }

结果

Unity：在一个接口有多个实现的情况下，如果没有进行别名区分，会选择最后注入的实现。

加入别名

        static void Main(string[] args)        {            IUnityContainer container = new UnityContainer();            //注入            container.RegisterType("bird");            container.RegisterType("plane");            IFlyable bird = container.Resolve("bird");            IFlyable plane = container.Resolve("plane");            bird.Fly();            plane.Fly();            Console.Read();        }

结果

注意

当一个接口有多个实现类的时候，注入的时候需要通过别名进行区分。

构造函数注入

我们添加一个接口

    /// 
    /// 具有会叫能力的接口    /// 
    public interface ISayable    {        IFlyable Fly { set; get; }        void Say();    }

添加一个鹦鹉类，有飞行能力，并且会叫

    /// 
    /// 鹦鹉类    /// 
    public class Parrot : ISayable    {        public IFlyable Fly        {            get;            set;        }        public Parrot(IFlyable fly)        {            this.Fly = fly;        }        public void Say()        {            Console.WriteLine("会叫....");        }    }

main方法中，注入

        static void Main(string[] args)        {            IUnityContainer container = new UnityContainer();            //注入            //构造函数中注入 鸟类对象            container.RegisterType();            container.RegisterType();            ISayable Parrot = container.Resolve();            Parrot.Fly.Fly();            Parrot.Say();            Console.Read();        }

结果

属性注入

    /// 
    /// 鹦鹉类    /// 
    public class Parrot : ISayable    {        [Dependency]        public IFlyable Fly        {            get;            set;        }        public void Say()        {            Console.WriteLine("会叫....");        }    }

通过在属性上面添加[Dependency]特性，即可注入。

Main方法与上面的相同。

结果同样。

初始化器注入

说是初始化器，其实就是一个方法。但是个特别的方法，这个方法需要添加特性[InjectionMethod]  

    /// 
    /// 鹦鹉类    /// 
    public class Parrot : ISayable    {               public IFlyable Fly        {            get;            set;        }        [InjectionMethod]        public void Init(IFlyable fly)        {            this.Fly = fly;        }        public void Say()        {            Console.WriteLine("会叫....");        }    }

结果