zoukankan      html  css  js  c++  java
  • [IOC]Unity使用

    Unity是什么?

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

    Unity特性

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

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

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

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

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

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

    Unity实践

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

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

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

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

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

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

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

    输出

     如果多个实现类呢?

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

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

    main方法

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

    结果

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

    加入别名

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

    结果

    注意

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

    构造函数注入

    我们添加一个接口

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

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

        /// <summary>
        /// 鹦鹉类
        /// </summary>
        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<IFlyable, Bird>();
                container.RegisterType<ISayable, Parrot>();
                ISayable Parrot = container.Resolve<ISayable>();
                Parrot.Fly.Fly();
                Parrot.Say();
                Console.Read();
    
            }

    结果

    属性注入

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

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

    Main方法与上面的相同。

    结果同样。

    初始化器注入

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

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

    结果

  • 相关阅读:
    学习方法
    编译原理词法分析程序
    06_05_词法分析
    顺序队列的基本操作
    使用默认参数的构造函数
    基于顺序栈的进制转换
    C语言之大数相加
    输入一个年输出其天干地支纪年法的表达式
    队列的链式存储及其基本运算
    队列的顺序存储及其基本操作
  • 原文地址:https://www.cnblogs.com/wolf-sun/p/5798536.html
Copyright © 2011-2022 走看看