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

NOoK 0:28:03 

字典是索要你手工业改代码的

NOoK 23:30:52 
要不要做题?
NOoK 23:31:28 
1个肆则运算的
经过素节 2三:3二:0陆 
说说看
NOoK 23:32:06 
可以吗,我上床了,晚安咯
NOoK 23:33:30 
因而不一样的计划,加载分化的程序集,落成四则运算
NOoK 23:34:19 
输入多个参数,运算得到结果
NOoK 23:35:01 
不容许用反射
经过新秋 二三:3伍:3一 
其它条件吧?
NOoK 23:35:39 
没有了
途经季秋 2三:3六:3三 
运用程序集,却不允许用反射?
NOoK 23:36:42 
自己不怕想通过五个数字,获得结果,怎么运算作者不管,只要给自身结果就好
NOoK 23:37:07 
您能够写到一个程序集里面
行经新秋 二三:三7:2八 
经过就是修改配置?
NOoK 23:37:29 
本人说错了,加载程序集正是反射
NOoK 23:37:51 
哥,你问偏了
NOoK 23:38:11 
经过你写好
NOoK 23:38:34 
由此配备修改
行经商节 贰叁:3捌:5一 
OK,我try一下
NOoK 23:39:09 
大家你消息啊,哈哈

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

NOoK 0:27:38 

 

 

 

只是加2个类和修改switch,代码过去如下:

 

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:25:40 

再回头看那段话,精通了,IOC原来如此子的:

那是反光吗?

 

接下来加上反射

XML,NOoK 0:23:45 
那正是了
路过首秋 0:二四:2二 
那东西写了多如牛毛,然而没感觉到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替换你至极字典了

意识是E文的,于是回复:

NOoK 0:15:31 
XML 1
NOoK 0:15:37 
那边能写1个字典吗
NOoK 0:15:46 
那不就是键值对吧

历经秋日 0:二6:1一 

XML 2XML 3IOC 演进2

OK,笔者付诸了最后代码:

NOoK 0:26:18 

好吧,很复杂的话,要分类就像是此了:

差不多上话就拧到那了,后边也没多拧几句,到了洗洗睡了的小时。

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

譬如说您能够集成AOP

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

经由孟秋 0:二伍:3二 

新兴中间拧了阵阵,基本没拧在一起,我要的是实战场景,他老给笔者讲理论。

XML 4XML 5IOC演进

于是乎笔者就迁就他学理论了,小编寻找看了看IOC的的主导介绍:

接下去领悟“注重注入、控制反转”七个字:

怎么工作吧?

紧接着她让自身下载她的处女开源项目,让自家看看:

NOoK 0:02:58 
若果那里的作业很负责呢
NOoK 0:03:04 
不是简单的四则运算
NOoK 0:03:08 
你如何做
行经商节 0:0三:1四 
很负责?
NOoK 0:03:43 
很复杂
NOoK 0:03:48 
手误
历经秋季 0:03:50 
既然如此是题材,你就举个现象,笔者按场景完成
NOoK 0:04:06 
您应有写5个类,对不对
NOoK 0:04:11 
个别达成多种运算
NOoK 0:04:21 
比那样写四个类要好
NOoK 0:04:28 
以往扩充就可以再写3个类

听说安顿,加个switch,消除了,可是既然大家在说IOC,肯定是内需不停演进。

控制反转:

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

 

那不难精通

先是Program里的switch本来是调用new A()那个目的,经过演进后,变成调用IGetResult接口了。
故而Program本来是凭借new A()对象,结果被IGetResult接口给插了菊华。
终极就是Program只调用IGetResult接口,Programe和new A()未有一向依赖关系。
那正是借助注入的分解了。

最后的须求,消灭switch

 

oC便是IoC,不是如何技艺,与GoF1样,是1种设计情势。

 

本来了,资料还有一大堆,就不详细贴了。

好端端说的,new A()对象,是由Program写死在代码里的了,也便是控制权是在Program里。
代码演进之后,对象的发出的控制权转移到安排文件里。
那正是控制(权)反转的解说了。

经由金天 0:28:15 

不需求改代码了

历经高商 0:贰6:3八 

是的

依傍注入:

接下去正是终止理论了:

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

依据须要,2-三分钟后,小编就上海图书馆了:

 

早在200四年,马丁 Fowler就提出了“哪些方面包车型地铁主宰被反转了?”那一个题材。他总计出是凭借对象的收获被反转了。基于这一个结论,他为操纵反转创立了贰个越来越好的名字:重视注入。许多匪夷所思的行使(比HelloWorld.java尤其美丽,特别错综复杂)都以由多少个也许越多的类经过互相的合营来促成业务逻辑,那使得各类对象都急需,与其同盟的指标(也便是它所依赖的靶子)的引用。要是那些获得进度要靠本身完结,那么如您所见,那将招致代码中度耦合并且难以测试。
IoC 亦称为 “信赖倒置原理”(“Dependency Inversion Principle”)。大致全部框架都采纳了“倒置注入(Fowler 200肆)技巧,这可说是IoC原理的一项应用。SmallTalk,C++, Java 或各样.NET 语言等面向对象程序语言的程序员已采用了这几个规律。
操纵反转是Spring框架的中坚。
使用控制反转,对象在被成立的时候,由一个调控类别内享有目的的外场实体,将其所倚重的靶子的引用,传递给它。也能够说,重视被注入到对象中。所以,控制反转是,关于1个指标如何获得她所依靠的靶子的引用,这么些义务的反转。

你看自己的代码,若是扩充三个类,ResultRegList那里还亟需再登记

途经上秋 22:3二:肆叁 
怎么还写E文的
NOoK 22:33:03 
直白在 CodePlex 上写的介绍
NOoK 22:33:08 
接下来就粘过来了
NOoK 22:33:15 
结果还被天涯论坛下架了。。。
NOoK 22:34:40 
悲催的
路太早秋 22:3伍:34 
谁让你 Look it on CodePlex
NOoK 22:35:41 
。。。 

 

新兴她为了拧过小编,决定给笔者培养一下,给本身出了道题:

小说地址: http://www.cnblogs.com/lenic/archive/2013/06/04/3117893.html

刚发过去,就来一句:能够领到一个接口吗

肆则变伍则:

能够把IoC格局作为是工厂形式的升华,能够把IoC看作是多少个大工厂,只不过这一个大工厂里要转变的目的都以在XML文件中提交定义的,然后选用Java 的“反射”编制程序,依据XML中付出的类名生成对应的对象。从达成来看,IoC是把原先在工厂方法里写死的靶子生成代码,改变为由XML文件来定义,也正是把工厂和目的生成那两边独立分隔离来,指标便是增长灵活性和可维护性。

 

昨日有网上朋友Call笔者留言,说她写了个DI架构,让自个儿有时间看望,于是作者就上去看了:

NOoK 0:11:51 
自笔者前日要加二个业务
NOoK 0:12:00 
逻辑是 (a + b) * a
NOoK 0:12:07 
怎么办 

后来的闲聊,小编让她给自家举三个实用场景,毕竟小编是实战派的,壹种形式或壹种东东,只有摆在现实的气象,并且有过深远的选择印迹,才能记的深,用的劳。

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

 

NOoK 0:27:55 

NOoK 0:26:54 

XML 6

NOoK 0:28:47 

NOoK 0:27:42 

各个IOC都不雷同,最简便的正是你写的那种字典

        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:26:37 

唯有变更为反射,能够化解

    }
}

XML 7XML 8IOC 演进3

像这么些设计方式的文章,一来便是UML图,举个例子基本就是猫和狗,要不正是会飞的野鸭。
费笔者拾八层心血,终于了然明白了。
第叁天一清醒,基本没影像。
再过些天。。。连设计方式的名字都不知叫什么了。

我错了 

IOC正是安排一下就能够了

透过三个尺度,找到所急需的落到实处类,看似更像反射

NOoK 0:26:09 

 

出于本身对IOC,即使曾数十次看过网上的稿子介绍,除了“重视注入,控制反转”这多少个字,未有剩余的存档回忆了。

丰盛壹些制造前、创设后的风浪

 

NOoK 0:26:49 

NOoK 0:27:33 

你看来了吧?

文章有点长,不领悟您通晓了没。

支配反转(Inversion of Control,英文缩写为IoC)是一个生死攸关的面向对象编制程序的原理来收缩总括机程序的耦合难点。 控制反转还有贰个名字称为重视注入(Dependency Injection)。简称DI。

 

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

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

NOoK 0:28:29 

 

NOoK 22:36:09 
明天再修改一下啊
路过孟秋 2二:三七:26 
毕生都习惯写英文?
NOoK 22:37:40 
必然不是呀
NOoK 22:38:03 
在 CodePlex 上边写了,懒得改就贴过来了
历经上秋 2二:3捌:4三 
一生也在CodePlex上边写?
NOoK 22:38:54 
率先个开源项目。。。
NOoK 22:40:35 
改好了再说吧
经过秋季 2贰:40:四陆 
 
NOoK 22:41:14 
您可以下载代码看看,维护了好几年了
历经穷秋 2贰:肆三:一七 
Ok,我看看
经由晚秋 2贰:4八:二叁 
扫了弹指间,不是很清楚
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,没布置 

都做了广大办事的

相关文章

网站地图xml地图