昨日有网友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分钟后,我就是直达图了:

图片 1

依据配置,加个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 
其后扩展就好重写一个像样

 

哼吧,很复杂的话,要分类就如此了:

 

图片 2图片 3IOC演进

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)
        {
            switch (GetConfig())
            {
                case “+”:
                    return new A().GetResult(a,b);
                case “-“:
                    return new B().GetResult(a, b);
                case “*”:
                    return new C().GetResult(a, b);
                case “/”:
                    return new D().GetResult(a, b);
            }
            return 0;
        }
        static string GetConfig()
        {
            string config = AppDomain.CurrentDomain.BaseDirectory + “config.ini”;
            return File.ReadAllText(config);
        }
    }
    public class A
    {
        public int GetResult(int a, int b)
        {
            return a + b;
        }
    }
    public class B
    {
        public int GetResult(int a, int b)
        {
            return a – b;
        }
    }
    public class C
    {
        public int GetResult(int a, int b)
        {
            return a * b;
        }
    }
    public class D
    {
        public int GetResult(int a, int b)
        {
            return a / b;
        }
    }

 

 

适发过去,就来同样句:可以领一个接口也

转了改变,代码发过去如下:

图片 4图片 5IOC 演进2

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;
            switch (GetConfig())
            {
                case “+”:
                    iResult = new A();
                    break;
                case “-“:
                    iResult = new B();
                    break;
                case “*”:
                    iResult = new C();
                    break;
                case “/”:
                    iResult = new D();
                    break;
            }
            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;
        }
    }

季虽说变五虽说:

NOoK 0:11:51 
自己现在使加以一个事务
NOoK 0:12:00 
逻辑是 (a + b) * a
NOoK 0:12:07 
怎么办 

 

徒是加一个接近及改动switch,代码过去如下:

图片 6图片 7IOC 演进3

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;
            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);
        }
        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;
        }
    }

 

最后的需要,消灭switch

NOoK 0:15:31 
图片 8
NOoK 0:15:37 
这边能写一个字典吗
NOoK 0:15:46 
立不就是键值对也

OK,我被起了最后代码:

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;
            }
        }

    }
}

 

对接下便是终止理论了:

NOoK 0:23:45 
立马就算是了
行经秋天 0:24:22 
即时东西写了众多,不过没有发ioc的存
NOoK 0:24:23 
如若下又续加逻辑,只要写一个IGetResult接口的兑现类似,再安排到字典里面,就可以了
NOoK 0:24:34 
颇字典,其实就算是ioc的雏形
NOoK 0:24:44 
IOC说到底,就是这么的一个字典
NOoK 0:25:03 
由此一个口径,找到所要的落实类似
NOoK 0:25:09 
然后用到逻辑上
NOoK 0:25:12 
就好了
NOoK 0:25:27 
重复改善,就是之所以IOC替换你死字典了

历经秋天 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模式作为是厂模式之提高,可以把IoC看作是一个老大工厂,只不过是老工厂里要扭转的对象还是以XML文件中受来概念之,然后使用Java 的“反射”编程,根据XML中叫起的类名生成对应的目标。从贯彻来拘禁,IoC是拿原先以厂方法里描写很的对象特别成代码,改变为由XML文件来定义,也就是是管工厂和对象好成这两者独立分隔开来,目的就是是增进灵活性和可维护性。

通下去理解“依赖注入、控制反转”八个字:

 

依赖注入:

 

率先Program里的switch本来是调用new A()这个目标,经过演进后,变成调用IGetResult接人了。
于是Program本来是恃new A()对象,结果给IGetResult接口给插了菊花。
最后便是Program只调用IGetResult接口,Programe和new A()没有直接依赖关系。
这就算是赖注入的说了。

 

 

操纵反转:

 

常规说之,new A()对象,是由Program写深在代码里之了,相当给控制权是在Program里。
代码演进之后,对象的起的控制权转移到布置文件里。
顿时就是决定(权)反转的诠释了。

 

 

章有硌长,不知道你懂得了未曾。

相关文章

网站地图xml地图