设计模式のIOC(控制反转)

 一、什么是Ioc

　　IoC（Inverse of Control）的字面意思是控制反转，它包括两个内容： 控制、反转

　　可以假设这样一个场景：火车运货，不同类型的车厢运送不同类型的货物，板车运送圆木，罐车运送柴油，箱车运送水果。那么对于运送货物这件事，需是列车挂不同的车厢运送货物。显然列车和运送货物之间是有依赖关系的（控制：依赖关系）。我们把列车挂什么样的车厢交给调度中心，而不是交给列车决定，这就形成了依赖反转。

　　因为IoC确实不够开门见山，因此业界曾进行了广泛的讨论，最终软件界的泰斗级人物Martin Fowler提出了DI（依赖注入：Dependency Injection）的概念用以代替IoC，即让调用类对某一接口实现类的依赖关系由第三方（容器或协作类）注入，以移除调用类对某一接口实现类的依赖。“依赖注入”这个名词显然比“控制反转”直接明了、易于理解。 

依赖注入和控制反转是同一概念吗？

        根据上面的讲述，应该能看出来，依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

        其实IoC/DI对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC/DI容器来创建并注入它所需要的资源了。

这么小小的一个改变其实是编程思想的一个大进步，这样就有效的分离了对象和它所需要的外部资源，使得它们松散耦合，有利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

       举个例子：有一个闹钟会问早安，当它地理位置定位在中国的时候，它会问候：早安；当在美国的时候，它会问候：Good Morning；那么我们把闹钟看做一个客户，问候看做一个服务，这个闹钟是依赖于服务的。闹钟遵从OCP原则应该有一个SayMorning的注入点，而问候就需要使用策略模式列出。实现这个功能：

public interface ISayMorning
{

    void SayMorning();
}

public class ChinesePosition:ISayMorning
{
    void SayMorning()
    {
        Console.Writeline("早安！");
    }
}

public class EnglishPosition:ISayMorning
{
    void SayMorning()
    {
    Console.Writeline("GoodMorning!");
    }
}

//下面创建客户

public class ClockClient()
{
    public ISayMorning SayService{set;}
    public Set_Sayservices(ISayMorning sayService)
    {
        SayService=sayService;
    }

    public SayMorning()
    {
       SayService.SayMorning();
    }
}

//主函数中

var clock=new ClockClient();
var saysChinese=new ChinesePosition();
clock.Set_Sayservices(saysChinese);
clock.SayMorning();

以上，闹钟说话依赖于说话服务，说话服务有很多策略（算法），我们将服务注入（DL）客户，将客户的依赖项（服务）反转到对象创建后再根据类别注入选择，这就形成了依赖反转（IOC）。这样做的的好处是策略变化（地区），我们只要新建类就好了

而不用修改已经写好的代码，实现了OCP（设计模式遵循的六大原则之 开闭原则）。

       

二、几个相似相关的概念

依赖倒置原则（DIP）：一种软件架构设计的原则（抽象概念）。

控制反转（IoC）：一种反转流、依赖和接口的方式（DIP的具体实现方式）。

依赖注入（DI）：IoC的一种实现方式，用来反转依赖（IoC的具体实现方式）。

IoC容器：依赖注入的框架，用来映射依赖，管理对象创建和生存周期（DI框架）。

三、Ioc的类型

IOC的实现有三种方式

构造注入：就是将开头例子中的Setter方式，在创建客户对象的时候，初始化进入。

Setter注入：就是开头的例子。

依赖获取。就是在注入的时候，利用一下虚拟工厂（Abstract Factory），这种适用于服务不仅一种的时候，比如我们赋予闹钟报时功能。

1、构造函数注入 

public Class SayHello
{
    private IPeople _people;
    public SayHello(IPeople  p)

    {
        _people=p;
    }

　　 public void Say()
    {
        _people.Say();

    }

}

2、属性注入

using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest 
{ 
    [TestClass] 
    public class SetterInjectionTest 
    { 
        class Client 
        { 
            private IWeatherReader reader; 
            public IWeatherReader Reader 
            { 
                get { return reader; } 
                set { reader = value; } 
            } 
        }

        [TestMethod] 
        public void Test() 
        { 
            IWeatherReader reader = new Assembler<IWeatherReader>().Create(); 
            Client client = new Client(); 
            client.Reader = reader; 
            Assert.IsNotNull(client.Reader); 
        } 
    } 
}

也可以写一个Setter方法

3、接口注入

using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest 
{ 
    [TestClass] 
    public class InterfaceInjectionTest 
    { 
        interface IClientWithWeatherReader 
        { 
            IWeatherReader Reader { get; set;} 
        } 

        class Client : IClientWithWeatherReader 
        { 
            private IWeatherReader reader; 

            #region IClientWithWeatherReader Members 
            public IWeatherReader Reader 
            { 
                get { return reader; } 
                set { reader = value; } 
            } 
            #endregion 
        } 

        [TestMethod] 
        public void Test() 
        { 
            IWeatherReader reader = new Assembler<IWeatherReader>().Create(); 
            Client client = new Client(); 
            IClientWithWeatherReader clientWithReader = client; 
            clientWithReader.Reader = reader; 
            Assert.IsNotNull(clientWithReader.Reader); 
        } 
    } 
} 

4、依赖获取

public interface ISayMorning
{

    void SayMorning();
}

public class ChinesePosition:ISayMorning
{
    void SayMorning()
    {
        Console.Writeline("早安！");
    }
}

public class EnglishPosition:ISayMorning
{
    void SayMorning()
    {
    Console.Writeline("GoodMorning!");
    }
}

public interface IFactory
{
    ISayTime MakeTimeSayer();
     ISayMoring MakeMorningSayer();
}

public class FactoryAmerican:IFactory
{
     public ISayTime MakeTimeSayer()
    {
      return new EnglishPositionTime(); //未实现
    }
      public ISayMoring MakeMorningSayer()
    {
      return new EnglishPosition();
    }
}

//位于中国的工厂
public class FactoryChinese:IFactory
{
     public ISayTime MakeTimeSayer()
    {
      return new ChinesePositionTime(); //未实现
    }
      public ISayMoring MakeMorningSayer()
    {
      return new ChinesePosition();
    }
}

public statics class FactoryContainer
{
       static FactoryContainer()
        {
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load("Config.xml");
            XmlNode xmlNode =xmlDoc.ChildNodes[1].ChildNodes[0].ChildNodes[0];
                          
            if ("Chinese" == xmlNode.Value)
            {
                factory = new FactoryChinese();
            }
            else if ("American" == xmlNode.Value)
            {
                factory = new FactoryAmerican();
            }
            else
            {
                throw new Exception("Factory Init Error");
            }
        }
    }
}

//调用
           IFactory factory = FactoryContainer.factory;
            IWindow window = factory.SayMorning();

这样，我们可以用过xml文件配置工厂（也就是不同的定位条件）。

四、一个例子

C#

using System; 
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer 
{ 
    /// <summary> 
    /// 抽象的处理对象 
    /// </summary> 
    public interface IObjectWithGuid 
    { 
        string Guid { get; set;} 
    } 
}

定义需要注入的限制接口，并用一个Attribute管理它 
C#

using System; 
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer 
{ 
    /// <summary> 
    /// 需要注入的用以限制最大数量的接口 
    /// </summary> 
    public interface ICapacityConstraint 
    { 
        int Max { get;} 
    } 

    public class CapacityConstraint : ICapacityConstraint 
    { 
        private int max; 
        public CapacityConstraint(){this.max = 0;} // 默认情况下不限制 
        public CapacityConstraint(int max) { this.max = max; } 
        public int Max { get { return max; } } 
    } 

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] 
    public class ConstraintAttribute : Attribute 
    { 
        private ICapacityConstraint capacity; 
        public ConstraintAttribute(int max) { this.capacity = new CapacityConstraint(max); } 
        public ConstraintAttribute() { this.capacity = null; } 
        public ICapacityConstraint Capacity { get { return capacity; } } 
    } 
} 

Assembler上增加通过Attribute注入限制的响应。 

using System; 
using System.Collections.Generic; 
namespace VisionLogic.Training.DependencyInjection.Scenario.Attributer 
{ 
    public class Assembler 
    { 
        /// <summary> 
        /// 登记相关类型对“最大容量”属性的使用情况 
        /// </summary> 
        private IDictionary<Type, ConstraintAttribute> attributeRegistry = new Dictionary<Type, ConstraintAttribute>(); 

        /// <summary> 
        /// 登记每个类型（如须受到“最大容量”属性限制的话），实际已经创建的对象数量 
        /// </summary> 
        private IDictionary<Type, int> usageRegistry = new Dictionary<Type, int>(); 
        public T Create<T>() where T : IObjectWithGuid, new() 
        { 
            ICapacityConstraint constraint = GetAttributeDefinedMax(typeof(T)); 
            if ((constraint == null) || (constraint.Max <= 0)) // max <= 0 代表是不需要限制数量的。 
                return InternalCreate<T>(); 
            else 
            { 
                if (usageRegistry[typeof(T)] < constraint.Max) // 检查是否超出容量限制 
                { 
                    usageRegistry[typeof(T)]++; // 更新使用情况注册信息 
                    return InternalCreate<T>(); 
                } 
                else 
                    return default(T); 
            } 
        } 

        // helper method 
        // 直接生成特定实例，并setter 方式注入其guid。 
        private T InternalCreate<T>() 
        where T : IObjectWithGuid, new() 
        { 
            T result = new T(); 
            result.Guid = Guid.NewGuid().ToString(); 
            return result; 
        } 

        /// helper method. 
        // 获取特定类型所定义的最大数量, 同时视情况维护attributeRegistry 和usageRegistry 的注册信息。 
        private ICapacityConstraint GetAttributeDefinedMax(Type type) 
        { 
            ConstraintAttribute attribute = null; 
            if (!attributeRegistry.TryGetValue(type, out attribute)) //新的待创建的类型 
            { 
                // 填充相关类型的“最大容量”属性注册信息 
                object[] attributes = type.GetCustomAttributes(typeof(ConstraintAttribute), false); 
                if ((attributes == null) || (attributes.Length <= 0)) 
                    attributeRegistry.Add(type, null); 
                else 
                { 
                    attribute = (ConstraintAttribute)attributes[0]; 
                    attributeRegistry.Add(type, attribute); 
                    usageRegistry.Add(type, 0); // 同时补充该类型的使用情况注册信息 
                } 
            } 
            if (attribute == null) 
                return null; 
            else 
                return attribute.Capacity; 
        } 
    } 
} 

4.2对方案的测试 

using Microsoft.VisualStudio.TestTools.UnitTesting; 
using VisionLogic.Training.DependencyInjection.Scenario.Attributer; 
namespace VisionLogic.Training.DependencyInjection.Scenario.UnitTest.Attributer 
{ 
    [TestClass()] 
    public class AssemblerTest 
    { 
        public abstract class ObjectWithGuidBase : IObjectWithGuid 
        { 
            protected string guid; 
            public virtual string Guid 
            { 
                get { return guid; } 
                set { guid = value; } 
            } 
        } 

        [Constraint(2)] // 通过属性注入限制 
        public class ObjectWithGuidImplA : ObjectWithGuidBase { } 
        [Constraint(0)] // 通过属性注入限制 
        public class ObjectWithGuidImplB : ObjectWithGuidBase { } 
        [Constraint(-5)] // 通过属性注入限制 
        public class ObjectWithGuidImplC : ObjectWithGuidBase { } 
        public class ObjectWithGuidImplD : ObjectWithGuidBase { } 

        [TestMethod] 
        public void Test() 
        { 
            Assembler assembler = new Assembler(); 
            for (int i = 0; i < 2; i++) 
            Assert.IsNotNull(assembler.Create<ObjectWithGuidImplA>()); 
            Assert.IsNull(assembler.Create<ObjectWithGuidImplA>()); // 最多两个 
            for (int i = 0; i < 100; i++) 
            Assert.IsNotNull(assembler.Create<ObjectWithGuidImplB>()); // 不限制 
            for (int i = 0; i < 100; i++) 
            Assert.IsNotNull(assembler.Create<ObjectWithGuidImplC>()); // 不限制 
            for (int i = 0; i < 100; i++) 
            Assert.IsNotNull(assembler.Create<ObjectWithGuidImplD>()); // 不限制 
        } 
    } 
}