傻嘎，IOC原来是这样子的

路过秋天  22: 32: 43 
怎么还写E文的
NOoK  22: 33: 03 
直接在 CodePlex 上写的介绍
NOoK  22: 33: 08 
然后就粘过来了
NOoK  22: 33: 15 
结果还被博客园下架了。。。
NOoK  22: 34: 40 
悲催的
路过秋天  22: 35: 34 
谁让你 Look it on CodePlex
NOoK  22: 35: 41 
。。。 

像那些设计模式的文章，一来就是UML图，举个例子基本就是猫和狗，要不就是会飞的鸭子。
费我十八层脑力，终于理解明白了。
第二天一睡醒，基本没印象。
再过些天。。。连设计模式的名字都不知叫什么了。

控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题。 控制反转还有一个名字叫做依赖注入（Dependency Injection）。简称DI。

早在2004年，Martin Fowler就提出了“哪些方面的控制被反转了？”这个问题。他总结出是依赖对象的获得被反转了。基于这个结论，他为控制反转创造了一个更好的名字：依赖注入。许多非凡的应用（比HelloWorld.java更加优美，更加复杂）都是由两个或是更多的类通过彼此的合作来实现业务逻辑，这使得每个对象都需要，与其合作的对象（也就是它所依赖的对象）的引用。如果这个获取过程要靠自身实现，那么如你所见，这将导致代码高度耦合并且难以测试。
IoC 亦称为 “依赖倒置原理”( " Dependency Inversion Principle ")。差不多所有框架都使用了“倒置注入(Fowler  2004)技巧，这可说是IoC原理的一项应用。SmallTalk，C++, Java 或各种.NET 语言等面向对象程序语言的程序员已使用了这些原理。
控制反转是Spring框架的核心。
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

oC就是IoC，不是什么技术，与GoF一样，是一种设计模式。

NOoK  23: 30: 52 
要不要做题？
NOoK  23: 31: 28 
一个四则运算的
路过秋天  23: 32: 06 
说说看
NOoK  23: 32: 06 
好吧，我睡觉了，晚安咯
NOoK  23: 33: 30 
通过不同的配置，加载不同的程序集，实现四则运算
NOoK  23: 34: 19 
输入两个参数，运算得到结果
NOoK  23: 35: 01 
不允许用反射
路过秋天  23: 35: 31 
其它条件呢？
NOoK  23: 35: 39 
没有了
路过秋天  23: 36: 33 
使用程序集，却不允许用反射？
NOoK  23: 36: 42 
我就是想通过两个数字，得到结果，怎么运算我不管，只要给我结果就好
NOoK  23: 37: 07 
你可以写到一个程序集里面
路过秋天  23: 37: 28 
过程就是修改配置？
NOoK  23: 37: 29 
我说错了，加载程序集就是反射
NOoK  23: 37: 51 
哥，你问偏了
NOoK  23: 38: 11 
过程你写好
NOoK  23: 38: 34 
通过配置修改
路过秋天  23: 38: 51 
OK，我try一下
NOoK  23: 39: 09 
我等你消息啊，哈哈

NOoK  0: 02: 58 
如果这里的业务很负责呢
NOoK  0: 03: 04 
不是简单的四则运算
NOoK  0: 03: 08 
你怎么办
路过秋天  0: 03: 14 
很负责？
NOoK  0: 03: 43 
很复杂
NOoK  0: 03: 48 
手误
路过秋天  0: 03: 50 
既然是题目，你就举个场景，我按场景实现
NOoK  0: 04: 06 
你应该写4个类，对不对
NOoK  0: 04: 11 
分别实现四种运算
NOoK  0: 04: 21 
比这样写一个类要好
NOoK  0: 04: 28 
以后扩展就可以再写一个类

NOoK  0: 15: 31 

NOoK  0: 15: 37 
这里能写一个字典吗
NOoK  0: 15: 46 
这不就是键值对吗

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace ABCD
{
     class Program
    {
         static  void Main( string[] args)
        {
             while ( true)
            {
                Console.Read();
                 int result = GetResult( 12,  4);
                Console.WriteLine(result);
            }
        }
         static  int GetResult( int a,  int b)
        {
            IGetResult iResult =  null;
             string key = GetConfig();
            iResult = ResultRegList.ResultList[key];
             return iResult.GetResult(a, b);
        }
         static  string GetConfig()
        {
             string config = AppDomain.CurrentDomain.BaseDirectory +  " config.ini ";
             return File.ReadAllText(config);
        }
    }
     public  interface IGetResult
    {
         int GetResult( int a,  int b);
    }
     public  class A : IGetResult
    {
         public  int GetResult( int a,  int b)
        {
             return a + b;
        }
    }
     public  class B : IGetResult
    {
         public  int GetResult( int a,  int b)
        {
             return a - b;
        }
    }
     public  class C : IGetResult
    {
         public  int GetResult( int a,  int b)
        {
             return a * b;
        }
    }
     public  class D : IGetResult
    {
         public  int GetResult( int a,  int b)
        {
             return a / b;
        }
    }
     public  class E : IGetResult
    {
         public  int GetResult( int a,  int b)
        {
             return (a + b) * a;
        }
    }
     public  class ResultRegList
    {
         static Dictionary< string, IGetResult> resultList =  new Dictionary< string, IGetResult>( 5);

         public  static Dictionary< string, IGetResult> ResultList
        {
             get
            {
                 if (resultList.Count ==  0)
                {
                    resultList.Add( " + ",  new A());
                    resultList.Add( " - ",  new B());
                    resultList.Add( " * ",  new C());
                    resultList.Add( " / ",  new D());
                    resultList.Add( " +* ",  new E());
                }
                 return resultList;
            }
        }


    }
}

路过秋天 0:25:32 

通过一个条件，找到所需要的实现类，看似更像反射

NOoK 0:25:40 

这是反射吗？

NOoK 0:26:09 

你看到了吗？

路过秋天 0:26:11 

你看我的代码，如果增加一个类，ResultRegList这里还需要再注册

NOoK 0:26:18 

是的

NOoK 0:26:37 

字典是需要你手工改代码的

路过秋天 0:26:38 

只有变更为反射，可以解决

NOoK 0:26:49 

IOC就是配置一下就可以了

NOoK 0:26:54 

不需要改代码了

NOoK 0:27:33 

每种IOC都不一样，最简单的就是你写的这种字典

NOoK 0:27:38 

然后加上反射

NOoK 0:27:42 

这容易理解

NOoK 0:27:55 

但是能用到生产上的IOC容器

NOoK 0:28:03 

都做了很多工作的

路过秋天 0:28:15 

什么工作呢？

NOoK 0:28:29 

比如你可以集成AOP

NOoK 0:28:47 

添加一些创建前、创建后的事件

可以把IoC模式看做是工厂模式的升华，可以把IoC看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的，然后利用Java 的“反射”编程，根据XML中给出的类名生成相应的对象。从实现来看，IoC是把以前在工厂方法里写死的对象生成代码，改变为由XML文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。