傻嘎，IOC原来是这样子的

发布时间：2020-05-22 19:01:12 所属栏目：程序设计来源：互联网

导读：昨天有网友Call我留言，说他写了个DI架构，让我有时间看看，于是我就上去看了：文章地址： http://www.cnblogs.com/lenic/archive/2013/06/04/3117893.html 发现是E文的，于是回复：路过秋天 22:32:43怎么还写E文的NOoK 22:33:03直接在 CodePlex 上写的介绍

昨天有网友Call我留言，说他写了个DI架构，让我有时间看看，于是我就上去看了：

文章地址： http://www.cnblogs.com/lenic/archive/2013/06/04/3117893.html

发现是E文的，于是回复：

路过秋天 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
。。。
我错了

接着他让我下载他的处女开源项目，让我看看：

NOoK 22:36:09
明天再修改一下吧
路过秋天 22:37:26
平时都习惯写英文？
NOoK 22:37:40
肯定不是啊
NOoK 22:38:03
在 CodePlex 上面写了，懒得改就贴过来了
路过秋天 22:38:43
平时也在CodePlex上面写？
NOoK 22:38:54
第一个开源项目。。。
NOoK 22:40:35
改好了再说吧
路过秋天 22:40:46
NOoK 22:41:14
你可以下载代码看看，维护了好几年了
路过秋天 22:43:17
Ok，我看看
路过秋天 22:48:23
扫了一下，不是很理解
NOoK 22:50:15
思路是，注册委托进字典，需要的时候，再用委托生成对象
NOoK 22:50:41
然后衍生了多个生存周期；
路过秋天 22:50:50
实用场景 ?
NOoK 22:51:42
一样啊
NOoK 22:51:56
就是IOC的使用场景
NOoK 22:52:46
这个核心代码，类似于Ninject，没配置

由于本人对IOC，虽然曾多次看过网上的文章介绍，除了“依赖注入，控制反转”这八个字，没有多余的存档记忆了。

后来的聊天，我让他给我举一个实用场景，毕竟我是实战派的，一种模式或一种东东，只有摆在现实的场景，并且有过深刻的使用痕迹，才能记的深，用的劳。

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

后来中间拧了一阵，基本没拧在一块，我要的是实战场景，他老给我讲理论。

于是我就迁就他学理论了，我搜索看了看IOC的的基本介绍：

控制反转（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
我等你消息啊，哈哈

根据要求，2-3分钟后，我就上图了：

根据配置，加个switch，解决了，不过既然我们在说IOC，肯定是需要不断演进。

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
以后扩展就可以再写一个类

好吧，很复杂的话，要分类就这样了：

IOC演进
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace ABCD
{
class Program
    {
staticvoid Main(string[] args)
        {
while (true)
            {
                Console.Read();
int result = GetResult(12,4);
                Console.WriteLine(result);
            }
        }
staticint GetResult(int a,int b)
        {
switch (GetConfig())
            {
case"+":
returnnew A().GetResult(a,b);
case"-":
returnnew B().GetResult(a,b);
case"*":
returnnew C().GetResult(a,b);
case"/":
returnnew D().GetResult(a,b);
            }
return0;
        }
staticstring GetConfig()
        {
string config = AppDomain.CurrentDomain.BaseDirectory + "config.ini";
return File.ReadAllText(config);
        }
    }
publicclass A
    {
publicvoid GetResult(int a,int b)
        {
return a + b;
        }
    }
publicclass B
    {
publicvoid GetResult(int a,int b)
        {
return a - b;
        }
    }
publicclass C
    {
publicvoid GetResult(int a,int b)
        {
return a * b;
        }
    }
publicclass D
    {
publicvoid GetResult(int a,int b)
        {
return a / b;
        }
    }

刚发过去，就来一句：可以提取一个接口吗

改了改，代码发过去如下：

IOC 演进2
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace ABCD
{
class Program
    {
staticvoid Main(string[] args)
        {
while (true)
            {
                Console.Read();
int result = GetResult(12,int b)
        {
            IGetResult iResult = null;
switch (GetConfig())
            {
case"+":
                    iResult = new A();
break;
case"-":
                    iResult = new B();
break;
case"*":
                    iResult = new C();
break;
case"/":
                    iResult = new D();
break;
case"+*":
                    iResult = new E();
break;
            }
return iResult.GetResult(a,b);
        }
staticstring GetConfig()
        {
string config = AppDomain.CurrentDomain.BaseDirectory + "config.ini";
return File.ReadAllText(config);
        }
    }
publicinterface IGetResult
    {
int GetResult(int a,int b);
    }
publicclass A : IGetResult
    {
publicint GetResult(int a,int b)
        {
return a + b;
        }
    }
publicclass B : IGetResult
    {
publicint GetResult(int a,int b)
        {
return a - b;
        }
    }
publicclass C : IGetResult
    {
publicint GetResult(int a,int b)
        {
return a * b;
        }
    }
publicclass D : IGetResult
    {
publicint GetResult(int a,int b)
        {
return a / b;
        }
    }
publicclass E : IGetResult
    {
publicint GetResult(int a,int b)
        {
return (a + b) * a;
        }
    }

四则变五则：

NOoK 0:11:51
我现在要加一个业务
NOoK 0:12:00
逻辑是 (a + b) * a
NOoK 0:12:07
怎么办

只是加一个类和修改switch，代码过去如下：

IOC 演进3
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace ABCD
{
class Program
    {
staticvoid Main(string[] args)
        {
while (true)
            {
                Console.Read();
int result = GetResult(12,int b)
        {
return (a + b) * a;
        }
    }

（编辑：安卓应用网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!