您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:TDD的一点想法和实践

新葡亰496net:TDD的一点想法和实践

发布时间:2019-09-08 01:22编辑:奥门新萄京娱乐场浏览(99)

    面向对象设计(OOD)有利于大家付出出高质量、易扩大以及易复用的次第。当中,OOD有一个主要的理念那就是依附倒置原则(DIP)。

    讲到IOC容器,就必需提到DIP(正视倒置原则)。

    <blockquote>
    本连串重要翻译自《ASP.NET MVC Interview Questions and Answers 》- By Shailendra Chauhan,想看匈牙利(Hungary)语原版的可访问http://www.dotnettricks.com/free-ebooks机关下载。该书首要分为两片段,ASP.NET MVC 5、ASP.NET WEB API2。本书最大的本性是以面试问答的方式展开发展。通读此书,会补助你对ASP.NET MVC有更加深档期的顺序的精晓。

    本连串重大翻译自《ASP.NET MVC Interview Questions and Answers 》- By Shailendra Chauhan,想看斯洛伐克语原版的可访谈活动下载。该书主要分为两有的,ASP.NET MVC 5、ASP.NET WEB API2。本书最大的特点是以面试问答的款型举办实行。通读此书,会帮忙您对ASP.NET MVC有越来越深档案的次序的精晓。
    鉴于个体技能水平和塞尔维亚(Serbia)语水准也是少数的,因而错误难以避免,希望我们多多留言指正。

    本连串首要翻译自《ASP.NET MVC Interview Questions and Answers 》- By Shailendra Chauhan,想看德文原版的可访问机关下载。该书首要分为两部分,ASP.NET MVC 5、ASP.NET WEB API2。本书最大的表征是以面试问答的花样进行实行。通读此书,会帮忙您对ASP.NET MVC有越来越深档案的次序的知情。
    是因为个体才干水平和希伯来语水准也是零星的,由此错误在所无免,希望大家多多留言指正。

    借助倒置原则(DIP):一种软件架构划虚构计的口径(抽象概念)

    DIP是OOD(面向对象设计)的三个根本理念,在该标准上引申出了IOC(调节反转)DI(正视注入)IOC容器。

    由于个人本领水平和德语水准也是少数的,由此错误在劫难逃,希望大家多多留言指正。

    连续串导航
    Asp.net mvc 知多少(一)
    Asp.net mvc 知多少(二)
    Asp.net mvc 知多少(三)
    Asp.net mvc 知多少(四)
    Asp.net mvc 知多少(五)
    Asp.net mvc 知多少(六)
    Asp.net mvc 知多少(七)
    Asp.net mvc 知多少(八)
    Asp.net mvc 知多少(九)
    Asp.net mvc 知多少(十)

    一类别导航
    Asp.net mvc 知多少(一)
    Asp.net mvc 知多少(二)
    Asp.net mvc 知多少(三)
    Asp.net mvc 知多少(四)
    Asp.net mvc 知多少(五)
    Asp.net mvc 知多少(六)
    Asp.net mvc 知多少(七)
    Asp.net mvc 知多少(八)
    Asp.net mvc 知多少(九)
    Asp.net mvc 知多少(十)

    操纵反转(IoC):一种反转流、重视和接口的艺术(DIP的求实实现格局)

    居然讲到IOC容器,当然大家要先精通DIP。

    文山会海导航
    Asp.net mvc 知多少(一)
    Asp.net mvc 知多少(二)
    Asp.net mvc 知多少(三)
    Asp.net mvc 知多少(四)
    Asp.net mvc 知多少(五)
    Asp.net mvc 知多少(六)
    Asp.net mvc 知多少(七)
    Asp.net mvc 知多少(八)
    Asp.net mvc 知多少(九)
    Asp.net mvc 知多少(十)
    </blockquote>

    本节任重(英文名:rèn zhòng)而道远疏解了正视注入

    Q91. 什么样是松耦合以及怎么样促成松耦合?
    Ans. MVC设计情势最重大的功效之一正是关怀点分离
    故而,我们的应用程序的模块应该尽量的涵养单身,也正是涵养松耦合。它促使更易于的对应用程序举行测验和保障。
    经过行使Dependency Injection (DI,依赖注入)能够扶助大家贯彻应用程序各样模块之间的松耦合。


    Q92. 什么是Dependency Inversion Principle (DIP,信赖倒置原则)和IoC(调节反转)?
    Ans. 依赖倒置原则讲的是:

    • 高层模块不该依附低层模块,它们都应该借助于肤浅。
    • 泛泛不应该凭借于细节(具体的完结)。但细节应该借助于肤浅。
      注重倒置原则协理我们开辟松耦合的代码,并保管了高层模块重视于肤浅并非低层模块具体的贯彻。
      决定反转格局是对DIP的一种完结。
      IOC指的是一种框架或运转时的编制程序风格,用来调控造进程序流程。
      IOC意味着大家得以更换常规的操纵方法。它在DIP下能够贯彻。繁多基于.net框架的软件开荒都选用IOC。
      IOC更加的多的是八个通用术语,不止局限于DI。DI和ServiceLocator(服务定位器)情势是对IOC情势的一种达成方式。

    新葡亰496net 1

    比喻来讲,假如你客商端的类须求动用一个Service类组件,那么最好实施是让您的客商端类知道有个IService接口实际不是Service类,这种格局下,你能够每一日变动I瑟维斯的现实贯彻而不会停顿已经配备的代码。
    IoC and DIP
    DIP是指高层模块不该依赖低层模块而都应该凭借于肤浅。
    IOC是用来提供抽象,改造调节。IOC提供了有个别方法来兑现DIP。要是想让高层模块独立于低层模块,你必要反转调节本领使低层模块不去决定接口并成立对象。 最终IOC提供了调控反转的局地措施。

    新葡亰496net 2


    Q93. 什么是Dependency Injection (DI,正视注入)?
    Ans. DI 是一种软件设计方式,用来允许大家付出松耦合代码。DI是一种很好的主意去收缩软件模块之间的紧耦合关怀。DI帮忙越来越好的去管理软件中的功能更新和复杂度。DI的指标是让代码可珍重。
    依傍注入情势应用构造器对指标初叶化并提供应和须求要的正视给目的,也就象征允许你从类外界注入多个借助项。

    举例,要是你的客户端类供给运用一个服务类组件,那么您能做的正是令你的客户了然一类IService接口并不是服务类。那样,你就足以每一日变动Service类的贯彻而不会停顿已经配备的代码。

    新葡亰496net 3


    Q94. 什么是Service Locator(服务定位器)?
    Ans. 瑟维斯 Locator 是一种软件设计方式,使得我们得以开辟松耦合的代码。
    它实现了DIP法规,它很轻巧与现存代码一齐使用使,因为它能够使全体设计变得宽松而无需强制改造公共的接口。
    ServiceLocator形式引进了壹个locator(定位器)的对象,该指标用来消除注重,意味着通过在类中援引该定位器对象就能够减轻类的依赖项。

    新葡亰496net 4

    来看一个切实可行的实例:

    public interface IService {
        void Serve();
    }
    public class Service: IService {
        public void Serve() {
            Console.WriteLine("Service Called");
            //To Do: Some Stuff
        }
    }
    public static class LocateService {
        public static IService _Service {
            get;
            set;
        }
        public static IService GetService() {
            if (_Service == null) _Service = new Service();
            return _Service;
        }
    }
    public class Client {
        private IService _service;
        public Client() {
            this._service = LocateService.GetService();
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    class Program {
        static void Main(string[] args) {
            var client = new Client();
            client.Start();
            Console.ReadKey();
        }
    }
    

    Q95. 有哪三种格局贯彻依附注入?
    Ans. 首要有以下三种艺术:
    ** Constructor Injection (构造函数注入)**
    那是最常用的流入格局。当实例化类的时候经过给类的构造函数提供依赖项来兑现依附注入。注入的依赖能够在类的其余地点直接使用。适用于类供给贰个或八个依赖时。

    public interface IService {
        void Serve();
    }
    public class Service: IService {
        public void Serve() {
            Console.WriteLine("Service Called");
        }
    }
    public class Client {
        private IService _service;
        public Client(IService service) {
            this._service = service;
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client(new Service());
            client.Start();
            Console.ReadKey();
        }
    }
    

    Property Injection(属性注入)
    适用于类要求可选的依赖性时,大概须求可调换的兑现时,比方Log4Net。
    在运用时须求Null check。
    这种方式没有必要增添或改变构造函数。

    public class Client {
        private IService _service;
        public IService Service {
            set {
                this._service = value;
            }
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client();
            client.Service = new Service();
            client.Start();
            Console.ReadKey();
        }
    }
    

    Method Injection(方法注入)
    这种方式注入重视到单一的艺术,改注重仅仅被注入的不二等秘书技应用。
    适用于一体类无需凭借项,而只是有些方法须要。

    public class Client {
        private IService _service;
        public void Start(IService service) {
            this._service = service;
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client();
            client.Start(new Service());
            Console.ReadKey();
        }
    }
    

    Q96. 注重注入的益处是何许?
    Ans. 首要有以下好处:

    • 削减类间耦合
    • 扩充代码重用
    • 增进代码可维护性
    • 福利应用程序测量检验

    Q97. 什么是IOC或DI容器?
    Ans. IOC和DI描述的是同三个设计形式,平时能够相互使用。
    之所以有一些人会讲IOC容器,有一些人讲DI容器,其实它们都指的是同一个事物,所以不要被术语吸引。
    四个DI容器是一个机制用来创制注重并当需求正视的时候自动注入。当供给借助时它自动遵照央求成立对象并流入。DI容器用一种轻巧轻便的措施扶持我们管理应用程序的注重。
    咱俩也足以不选用DI容器来治本倚重,然则那样我们须要做越来越多的做事来让其扶助可配置和可管理。


    Q98. 有怎么着流行的DI容器?
    Ans. 未来,有那些不错的DI容器适用于.net。
    列举如下:
    Castle Windsor

    • 基于 Castle MicroKernel
    • 详尽的文书档案
    • 使用者多
    • Understands Decorator(驾驭装饰器)
    • Typed factories(类型工厂)
    • Commercial support available(官方扶助)

    Spring.NET

    • INTERCEPTION(拦截)
    • Comprehensive documentation(全体文书档案)
    • Commercial support available(官方援助)

    Autofac

    • Easy to learn API(易于学习的API)
    • second-generation DI Container(第二代DI容器)
    • Commercial support available(官方支持)

    Unity

    • INTERCEPTION(拦截)
    • Good documentation(文书档案卓绝)
    • Consistent API(一致的API)

    Ninject

    • Easy to learn API(易于学习的API)
    • Second-generation DI Container(第二代DI容器)

    Q99.什么是Test Driven Development (TDD,测验驱动开拓)?
    Ans. TDD是一个开销条件,在写代码在此以前先写测试。
    测量检验驱动应用程序的设计和开拓周期。
    在具备的测量试验通过在此以前,不能够签入代码。
    新葡亰496net 5


    Q100. ASP.NET MVC中有哪些常用的单元测量检验工具?
    Ans. ASP.NET MVC被规划为可测验的,而不需求重视IIS、数据库或附加的类。
    以下是相比较盛行的测验工具:
    • NUnit - NUnit是 Microsoft .NET上相比较盛行的单元测量试验框架。它的语法相对轻松易用。它提供了跑单元测量检验的GUI和命令行工具。NUnit提供有NuGet包供下载应用。
    • xUnit.NET - xUnit.NET提供了一种自动化运营单元测验的秘技。它大致、易于扩充、语法清晰。
    • Ninject 2 - Ninject提供连接应用程序中类的不二诀窍。
    • Moq - Moq提供了一种在测量试验时期模拟类和接口的机制。

    本节重要批注了依赖注入

    Q91. 什么是松耦合以及哪些落实松耦合?
    Ans. MVC设计情势最要害的功效之一正是关注点分离
    故此,我们的应用程序的模块应该尽恐怕的维持独立,也正是维持松耦合。它促使更便于的对应用程序进行测验和保卫安全。
    通过运用Dependency Injection (DI,重视注入)能够辅助大家兑现应用程序各类模块之间的松耦合。


    Q92. 什么是Dependency Inversion Principle (DIP,重视倒置原则)和IoC(调节反转)?
    Ans. 重视倒置原则讲的是:

    • 高层模块不该依赖低层模块,它们都应有借助于肤浅。
    • 空泛不应有凭借于细节(具体的落到实处)。但细节应该借助于肤浅。
      依赖倒置原则帮忙我们开采松耦合的代码,并保障了高层模块正视于肤浅实际不是低层模块具体的兑现。
      操纵反转情势是对DIP的一种达成。
      IOC指的是一种框架或运维时的编制程序风格,用来支配程序流程。
      IOC意味着我们可以改换常规的决定措施。它在DIP下能够完成。多数基于.net框架的软件开采都利用IOC。
      IOC越来越多的是一个通用术语,不止局限于DI。DI和ServiceLocator(服务定位器)方式是对IOC形式的一种完结方式。

    新葡亰496net 6

    比方来说,就算你顾客端的类需求利用一个Service类组件,那么最棒推行是让你的客商端类知道有个IService接口并非Service类,这种方法下,你能够随时变动IService的现实贯彻而不会搁浅已经布署的代码。
    IoC and DIP
    DIP是指高层模块不该借助低层模块而都应该依附于肤浅。
    IOC是用来提供抽象,改造调节。IOC提供了有个别措施来贯彻DIP。要是想让高层模块独立于低层模块,你要求反转调节技能使低层模块不去调控接口并创制对象。 最终IOC提供了决定反转的部分方法。

    新葡亰496net 7


    Q93. 什么是Dependency Injection (DI,正视注入)?
    Ans. DI 是一种软件设计格局,用来允许大家开采松耦合代码。DI是一种很好的法子去减弱软件模块之间的紧耦合关怀。DI支持越来越好的去管理软件中的功能更新和复杂度。DI的目标是让代码可保养。
    新葡亰496net:TDD的一点想法和实践。借助于注入形式采纳构造器对指标最初化并提供应和供给要的借助给指标,也就代表允许你从类外界注入三个依附项。

    比如,如若你的用户端类必要利用多个服务类组件,那么您能做的就是令你的客商明白一类IService接口并非服务类。那样,你就足以每日变动Service类的落到实处而不会有始无终已经安顿的代码。

    新葡亰496net 8


    Q94. 什么是瑟维斯 Locator(服务定位器)?
    Ans. 瑟维斯 Locator 是一种软件设计情势,使得大家得以开辟松耦合的代码。
    它达成了DIP法规,它很轻松与现存代码一齐利用使,因为它可以使全部规划变得宽松而无需强制更改公共的接口。
    ServiceLocator情势引进了二个locator(定位器)的指标,该对象用来缓和信赖,意味着通过在类中援用该定位器对象就能够化解类的借助项。

    新葡亰496net 9

    来看二个具体的实例:

    public interface IService {
        void Serve();
    }
    public class Service: IService {
        public void Serve() {
            Console.WriteLine("Service Called");
            //To Do: Some Stuff
        }
    }
    public static class LocateService {
        public static IService _Service {
            get;
            set;
        }
        public static IService GetService() {
            if (_Service == null) _Service = new Service();
            return _Service;
        }
    }
    public class Client {
        private IService _service;
        public Client() {
            this._service = LocateService.GetService();
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    class Program {
        static void Main(string[] args) {
            var client = new Client();
            client.Start();
            Console.ReadKey();
        }
    }
    

    Q95. 有哪二种格局贯彻依赖注入?
    Ans. 首要有以下两种方法:
    ** Constructor Injection (构造函数注入)**
    那是最常用的注入格局。当实例化类的时候经过给类的构造函数提供注重项来落到实处依附注入。注入的借助能够在类的其他市方直接行使。适用于类要求二个或多少个依据时。

    public interface IService {
        void Serve();
    }
    public class Service: IService {
        public void Serve() {
            Console.WriteLine("Service Called");
        }
    }
    public class Client {
        private IService _service;
        public Client(IService service) {
            this._service = service;
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client(new Service());
            client.Start();
            Console.ReadKey();
        }
    }
    

    Property Injection(属性注入)
    适用于类必要可选的依据时,或许需求可交流的落到实处时,比方Log4Net。
    在应用时索要Null check。
    这种方法不须求充实或改变构造函数。

    public class Client {
        private IService _service;
        public IService Service {
            set {
                this._service = value;
            }
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client();
            client.Service = new Service();
            client.Start();
            Console.ReadKey();
        }
    }
    

    Method Injection(方法注入)
    这种方法注入正视到单一的章程,改正视仅仅被注入的措施应用。
    适用于漫天类无需注重项,而单单有些方法需求。

    public class Client {
        private IService _service;
        public void Start(IService service) {
            this._service = service;
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client();
            client.Start(new Service());
            Console.ReadKey();
        }
    }
    

    Q96. 注重注入的裨益是何许?
    Ans. 主要有以下好处:

    • 减弱类间耦合
    • 充实代码重用
    • 加强代码可维护性
    • 福利应用程序测量检验

    Q97. 什么是IOC或DI容器?
    Ans. IOC和DI描述的是同多个设计情势,平时可以并行使用。
    进而有一些人会讲IOC容器,有些许人会说DI容器,其实它们都指的是同三个事物,所以不要被术语吸引。
    二个DI容器是三个体制用来创建注重并当要求依赖的时候自动注入。当要求借助时它自动依据央浼创立对象并流入。DI容器用一种简易轻易的主意扶助大家管理应用程序的信赖。
    我们也足以不利用DI容器来保管重视,不过那样咱们须求做越来越多的劳作来让其援助可配备和可管理。


    Q98. 有怎么样流行的DI容器?
    Ans. 未来,有非常多不易的DI容器适用于.net。
    列举如下:
    Castle Windsor

    • 基于 Castle MicroKernel
    • 详尽的文书档案
    • 使用者多
    • Understands Decorator(通晓装饰器)
    • Typed factories(类型工厂)
    • Commercial support available(官方扶助)

    Spring.NET

    • INTERCEPTION(拦截)
    • Comprehensive documentation(全部文书档案)
    • Commercial support available(官方帮忙)

    Autofac

    • Easy to learn API(易于学习的API)
    • second-generation DI Container(第二代DI容器)
    • Commercial support available(官方援助)

    Unity

    • INTERCEPTION(拦截)
    • Good documentation(文书档案杰出)
    • Consistent API(一致的API)

    Ninject

    • Easy to learn API(易于学习的API)
    • Second-generation DI Container(第二代DI容器)

    Q99.什么是Test Driven Development (TDD,测量试验驱动开垦)?
    Ans. TDD是多少个付出原则,在写代码在此之前先写测量试验。
    测验驱动应用程序的布置和开辟周期。
    在全数的测验通过从前,不可能签入代码。
    新葡亰496net 10


    Q100. ASP.NET MVC中有如何常用的单元测量试验工具?
    Ans. ASP.NET MVC被设计为可测量试验的,而无需依赖IIS、数据库或附加的类。
    以下是相比盛行的测量检验工具:
    • NUnit - NUnit是 Microsoft .NET上相比较盛行的单元测量试验框架。它的语法相对轻松易用。它提供了跑单元测量试验的GUI和命令行工具。NUnit提供有NuGet包供下载应用。
    • xUnit.NET - xUnit.NET提供了一种自动化运营单元测量检验的点子。它总结、易于增加、语法清晰。
    • Ninject 2 - Ninject提供连接应用程序中类的措施。
    • Moq - Moq提供了一种在测量检验时期模拟类和接口的建制。

    依傍注入(DI):IoC的一种达成格局,用来反转依赖(IoC的切切实实落到实处格局)

    大家来看下定义:

    本节首要讲明了依赖注入

    Q91. 怎么样是松耦合以及哪些落到实处松耦合?
    Ans. MVC设计情势最主要的效劳之一便是关心点分离
    为此,咱们的应用程序的模块应该尽量的维持独立,相当于维持松耦合。它促使更便于的对应用程序实行测量检验和保卫安全。
    透过利用Dependency Injection (DI,依赖注入)能够扶助大家落到实处应用程序各种模块之间的松耦合。


    Q92. 什么是Dependency Inversion Principle (DIP,正视倒置原则)和IoC(调节反转)?
    Ans. 信赖倒置原则讲的是:

    • 高层模块不应有借助低层模块,它们都应有借助于肤浅。
    • 空泛不应有借助于细节(具体的兑现)。但细节应该依附于肤浅。
      依傍倒置原则帮助大家开垦松耦合的代码,并确认保证了高层模块注重于肤浅实际不是低层模块具体的落到实处。
      调节反转格局是对DIP的一种实现。
      IOC指的是一种框架或运营时的编制程序风格,用来决定程序流程。
      IOC意味着大家得以变动不荒谬的主宰格局。它在DIP下得以落实。好些个基于.net框架的软件开辟都选用IOC。
      IOC更加多的是多个通用术语,不止局限于DI。DI和ServiceLocator(服务定位器)格局是对IOC格局的一种达成格局。

    新葡亰496net 11

    举例来说,假如你顾客端的类供给选用一个Service类组件,那么最棒施行是让您的顾客端类知道有个IService接口实际不是Service类,这种办法下,你能够每二二日变动IService的切实达成而不会有始无终已经配备的代码。
    IoC and DIP
    DIP是指高层模块不应该借助低层模块而都应有借助于肤浅。
    IOC是用来提供抽象,改换调整。IOC提供了一些格局来促成DIP。如若想让高层模块独立于低层模块,你要求反转调控本领使低层模块不去调节接口并创造对象。 最后IOC提供了决定反转的部分主意。

    新葡亰496net 12


    Q93. 什么是Dependency Injection (DI,依赖注入)?
    Ans. DI 是一种软件设计方式,用来允许大家付出松耦合代码。DI是一种很好的艺术去收缩软件模块之间的紧耦合关注。DI支持越来越好的去管理软件中的作用更新和复杂度。DI的指标是让代码可珍爱。
    依附注入格局应用构造器对目的发轫化并提供应和须要要的注重性给目的,也就象征允许你从类外界注入一个借助项。

    举个例子,假如你的顾客端类必要利用三个服务类组件,那么你能做的正是让你的顾客明白一类IService接口并不是服务类。那样,你就足以随时变动Service类的贯彻而不会一噎止餐已经安插的代码。

    新葡亰496net 13


    Q94. 什么是Service Locator(服务定位器)?
    Ans. Service Locator 是一种软件设计格局,使得大家得以开采松耦合的代码。
    它完毕了DIP准则,它很轻便与存活代码一齐利用使,因为它可以使全部设计变得宽松而不需求强制改造公共的接口。
    ServiceLocator方式引进了三个locator(定位器)的指标,该目的用来减轻正视,意味着通过在类中援用该定位器对象就能够化解类的注重性项。

    新葡亰496net 14

    SL图解

    来看五个具体的实例:

    public interface IService {
        void Serve();
    }
    public class Service: IService {
        public void Serve() {
            Console.WriteLine("Service Called");
            //To Do: Some Stuff
        }
    }
    public static class LocateService {
        public static IService _Service {
            get;
            set;
        }
        public static IService GetService() {
            if (_Service == null) _Service = new Service();
            return _Service;
        }
    }
    public class Client {
        private IService _service;
        public Client() {
            this._service = LocateService.GetService();
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    class Program {
        static void Main(string[] args) {
            var client = new Client();
            client.Start();
            Console.ReadKey();
        }
    }
    

    Q95. 有哪三种方式达成依附注入?
    Ans. 主要有以下二种艺术:
    ** Constructor Injection (构造函数注入)**
    那是最常用的流入情势。当实例化类的时候经过给类的构造函数提供依赖项来落到实处依附注入。注入的依赖性可以在类的另各省方向来动用。适用于类必要二个或多个依赖时。

    public interface IService {
        void Serve();
    }
    public class Service: IService {
        public void Serve() {
            Console.WriteLine("Service Called");
        }
    }
    public class Client {
        private IService _service;
        public Client(IService service) {
            this._service = service;
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client(new Service());
            client.Start();
            Console.ReadKey();
        }
    }
    

    Property Injection(属性注入)
    适用于类需求可选的依赖时,也许要求可调换的贯彻时,举例Log4Net。
    在使用时需求Null check。
    这种办法无需追加或涂改构造函数。

    public class Client {
        private IService _service;
        public IService Service {
            set {
                this._service = value;
            }
        }
        public void Start() {
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client();
            client.Service = new Service();
            client.Start();
            Console.ReadKey();
        }
    }
    

    Method Injection(方法注入)
    这种办法注入重视到单一的办法,改重视仅仅被注入的点子运用。
    适用于一体类无需借助项,而只是某些方法需求。

    public class Client {
        private IService _service;
        public void Start(IService service) {
            this._service = service;
            Console.WriteLine("Service Started");
            this._service.Serve();
            //To Do: Some Stuff
        }
    }
    //Builder
    class Program {
        static void Main(string[] args) {
            Client client = new Client();
            client.Start(new Service());
            Console.ReadKey();
        }
    }
    

    Q96. 重视注入的好处是什么?
    Ans. 首要有以下好处:

    • 减掉类间耦合
    • 扩充代码重用
    • 抓好代码可维护性
    • 便利应用程序测验

    Q97. 什么是IOC或DI容器?
    Ans. IOC和DI描述的是同一个设计情势,平日能够并行使用。
    因此有的人讲IOC容器,有些人说DI容器,其实它们都指的是同一个东西,所以不用被术语吸引。
    多少个DI容器是八个体制用来创造重视并当要求借助的时候自动注入。当须求依据时它自动依据须要创制对象并流入。DI容器用一种轻松轻易的方法扶持我们管理应用程序的借助。
    咱俩也能够不接纳DI容器来管理重视,可是这么大家要求做越来越多的干活来让其扶助可配备和可管理。


    Q98. 有什么流行的DI容器?
    Ans. 未来,有众多科学的DI容器适用于.net。
    列举如下:
    Castle Windsor

    • 基于 Castle MicroKernel
    • 详见的文书档案
    • 使用者多
    • Understands Decorator(通晓装饰器)
    • Typed factories(类型工厂)
    • Commercial support available(官方帮忙)

    Spring.NET

    • INTERCEPTION(拦截)
    • Comprehensive documentation(全体文书档案)
    • Commercial support available(官方帮助)

    Autofac

    • Easy to learn API(易于学习的API)
    • second-generation DI Container(第二代DI容器)
    • Commercial support available(官方帮衬)

    Unity

    • INTERCEPTION(拦截)
    • Good documentation(文档优异)
    • Consistent API(一致的API)

    Ninject

    • Easy to learn API(易于学习的API)
    • Second-generation DI Container(第二代DI容器)

    Q99.什么是Test Driven Development (TDD,测量检验驱动开荒)?
    Ans. TDD是三个付出原则,在写代码从前先写测量试验。
    测量试验驱动应用程序的设计和开拓周期。
    在全体的测量试验通过从前,不能够签入代码。

    新葡亰496net 15

    TDD开垦流程


    Q100. ASP.NET MVC中有啥常用的单元测验工具?
    Ans. ASP.NET MVC被设计为可测验的,而无需正视IIS、数据库或附加的类。
    以下是相比盛行的测验工具:
    • NUnit - NUnit是 Microsoft .NET上相比较盛行的单元测量检验框架。它的语法相对简便易行易用。它提供了跑单元测量检验的GUI和命令行工具。NUnit提供有NuGet包供下载应用。
    • xUnit.NET - xUnit.NET提供了一种自动化运营单元测量检验的方法。它大概、易于扩张、语法清晰。
    • Ninject 2 - Ninject提供连接应用程序中类的主意。
    • Moq - Moq提供了一种在测量试验时期模拟类和接口的编写制定。

    IoC容器:凭仗注入的框架,用来映射重视,管理对象创设和生存周期(DI框架)、

    依附倒置原则(DIP):一种软件架构划设想计的尺度(抽象概念)。

    Unity:是微软推出的IOC框架

    支配反转(IoC):一种反转流、依赖和接口的办法(DIP的切实落实际情形势)。

    TDD:测量检验驱动开采,是非常快开辟中的一项大旨实行和技巧,也是一种设计方法论

    依傍注入(DI):IoC的一种实现形式,用来反转依赖(IoC的求实完毕格局)。

     

    IoC容器:依赖注入的框架,用来映射注重,管理对象制造和生活周期(DI框架)。

    地点的从头到尾的经过都以抄的(俄文不好,放在这里备查),相关的剧情看了一部分,不明觉厉。

     

     

    DIP依赖倒置原则

    怎么是标准化?

    答:代表性则难点性的二个恒久词 行事所遵照的准绳

    DIP仅仅只是代表正视倒置的两个基于准绳而已。DIP是一种 软件设计原则,它唯有告诉你八个模块之间应当怎样借助,不过它并未告诉如何是好。

    DIP倡导高层模块定义了接口,将不再直接依赖于低层模块,低层模块担任兑现高层模块定义的接口。这样,当有新的低层模块达成时,不供给修改高层模块的代码。

    通过,大家得以总结出利用DIP的长处:

    • 能够修改一片段代码而不影响另外模块。
    • 能够修改一有的代码而不会让系统崩溃。
    • 零件松耦合,且可复用,升高支付功用。

    今日头条里相当多少人用了ATM机的生存例子来进展解说,ATM机为高层,底层为信用卡,DIP的准绳告诉大家ATM机来定义接口然后让银行卡来落到实处。那样的平价ATM机能够支撑很种种银行卡。

    早就写了二个酒吧读写房卡的前后相继,不一样的小吃摊门锁是分裂样的,同二个酒家也许有希望改换门锁,程序流程:

    IOC调控反转

    IOC是怎么样呢?

    IoC则是一种 软件设计格局,它报告您应该如何做,来清除相互正视模块的耦合。

    操纵反转(IoC),它为互相正视的机件提供抽象,将依赖(低层模块)对象的获取交给第三方(系统)来决定即借助对象不在被依赖模块的类中一直通过new来博取

    IoC有二种方法:重视注入和劳务一定

    那边就讲到依赖注入DI

    1.经过Api获取当前茶楼的门锁类型

    DI倚重注入

    DI就算将凭借对象的创制和绑定转移到被信赖对象类的外表来落成,将索要正视(低层模块)对象的援用传递给被重视(高层模块)对象。

    流入的点子有构造函数、属性、接口。

    咱俩来看下构造函数注入例子:

    先定义八个数据库操作方法接口

    • public interface ILinkmethod
    { 
    
            void Add(); 
    
    } 
    
    新增一个实现类
    
    public class SqlServerDal:
    ILinkmethod 
    
    { 
    
           public void Add() 
    
           { 
    
               Console.WriteLine("在数据库中添加一条订单!"); 
    
           } 
    
    } 
    
    public class ActionOrder 
    
      { 
    
            private ILinkmethod
    _ida;//定义一个私有变量保存抽象 
    
       
    
            //构造函数注入 
    
            public Order(ILinkmethod
    ida)
    
    
            { 
    
                _ida =
    ida;//传递依赖 
    
          } 
    
       
    
            public void Add() 
    
            { 
    
                _ida.Add(); 
    
            } 
    
    } 
    
    调用:
    
     static void Main(string[]
    args)
    
    
            { 
    
                SqlServerDal
    dal = new SqlServerDal();//在外部创建依赖对象 
    
                Order order
    = new Order(dal);//通过构造函数注入依赖 
    
       
    
                order.Add(); 
    
       
    
                Console.Read(); 
    
            }
    
    
    上面的基础铺垫后终于到我们的主题了: 
    
    ![](https://images2017.cnblogs.com/blog/646543/201709/646543-20170918163443321-1929650421.png)
    
    
    IOC容器
    =======
    
    IoC容器实际上是一个DI框架,
    它能简化我们的工作量。它包含以下几个功能:
    
    动态创建、注入依赖对象。
    
    管理对象生命周期。
    
    映射依赖关系。
    
    比较流行的Ioc容器:
    
    1. Ninject:  

    2. Castle Windsor:  

    3. Autofac:  

    4. StructureMap: 

    5. Unity:  

    注:依据园友 徐少侠 的提醒,MEF不该是IoC容器。作者又查看了部分材质,以为MEF作为IoC容器是有一点勉强,它的重要成效依旧用来应用程序增加,幸免生成虚弱的硬正视项。

     6. MEF:   

    另外,园友 aixuexi 建议Spring.NET也是比较盛行的IoC容器。

    7. Spring.NET: 

    园友 wdwwtzy 也推荐了一个不错的IoC容器:

    8. LightInject:   (推荐使用Chrome浏览器访问)

    上述IOC容器摘抄于木小楠整理。

    笔者们上面来中间讲授下Autofac,为了让我们越发轻易动手,请先了然上述剧情

    Autofac是一款IOC框架,比较于别的的IOC框架,如Spring.NET,Unity,Castle等等所含有的,它非常轻量级品质上非常高。

    我们来看下官方表达:

    2.只要急需则下载对应门锁的dll

    Adding Components

    Components are registered with a ContainerBuilder:

    var builder = new ContainerBuilder();

    Autofac can use a Linq expression, a .NET type, or a pre-built instance as a component:

    builder.Register(c => new TaskController(c.Resolve<ITaskRepository>()));

     

    builder.RegisterType<TaskController>();

     

    builder.RegisterInstance(new TaskController());

    Or, Autofac can find and register the component types in an assembly:

    builder.RegisterAssemblyTypes(controllerAssembly);

    Calling Build() creates a container:

    var container = builder.Build();

    To retrieve a component instance from a container, a service is requested. By default, components provide their concrete type as a service:

    var taskController = container.Resolve<TaskController>();

    To specify that the component's service is an interface, the As() method is used at registration time:

    builder.RegisterType<TaskController>().As<IController>();

    // enabling

    var taskController = container.Resolve<IController>();

     

    方法1:

    var builder = new ContainerBuilder();

    builder.RegisterType<TestService>();

    builder.RegisterType<TestDao>().As<ITestDao>();

    return builder.Build();

    方法二:

    为了统一管理 IoC 相关的代码,并防止在尾巴部分类库中四处援引 Autofac 那么些第三方组件,定义了壹个特意用于管理供给依附注入的接口与贯彻类的空中接力口 IDependency:

     

    /// <summary>

    /// 正视注入接口,表示该接口的落到实处类将自动注册到IoC容器中

    /// </summary>

    public interface IDependency

    { }

     

    本条接口未有任何方法,不会对系统的业务逻辑产生污染,全数须求张开信赖注入的接口,都要三回九转这几个空切口,比如:

    业务单元操作接口:

     

    /// <summary>

    /// 业务单元操作接口

    /// </summary>

    public interface IUnitOfWork : IDependency

    {

    ...

    }

     

    Autofac 是永葆批量子类注册的,有了 IDependency 那么些基接口,我们只必要Global 中很简单的几行代码,即可实现整个系统的信赖注入相称:

     

    ContainerBuilder builder = new ContainerBuilder();

    builder.RegisterGeneric(typeof(Repository<,>)).As(typeof(IRepository<,>));

    Type baseType = typeof(IDependency);

     

    // 获取具备相关类库的程序集

    Assembly[] assemblies = ...

     

    builder.RegisterAssemblyTypes(assemblies)

    .Where(type => baseType.IsAssignableFrom(type) && !type.IsAbstract)

    .AsImplementedInterfaces().InstancePerLifetimeScope();//InstancePerLifetimeScope 保险对象生命周期基于乞请

    IContainer container = builder.Build();

    DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

    3.兑现读写效率

    一、定义接口

    新建三个类库(Lock.Interface),代码如下:

    namespace Lock
    {
        public interface ILock
        {
            /// <summary>
            /// 门锁初始化
            /// </summary>
            /// <param name="password">初始化密码</param>
            /// <returns></returns>
            bool Init(int password);
    
        }
    }
    

    是否终于IoC了?(小编不分明)

    二、单元测量检验

    新葡亰496net,新建多少个单元测量检验项目(Lock.Tests),代码如下:

    1.门锁A单元测量试验

        /// <summary>
        /// 门锁A测试
        /// </summary>
        [TestClass()]
        public class LockATests
        {
            /// <summary>
            /// 初始化,password为正奇数
            /// </summary>
            [TestMethod()]
            public void InitTest()
            {
                ILock l = new LockA();
                var ret = l.Init(1);
                Assert.AreEqual(ret, true);
                ret = l.Init(2);
                Assert.AreEqual(ret, false);
                ret = l.Init(-1);
                Assert.AreEqual(ret, false);
            }
    
        }
    

    2.门锁B单元测量检验

        /// <summary>
        /// 门锁B测试
        /// </summary>
        [TestClass()]
        public class LockBTests
        {
            /// <summary>
            /// 初始化测试,password为正偶数
            /// </summary>
            [TestMethod()]
            public void InitTest()
            {
                ILock l = new LockB();
                var ret = l.Init(1);
                Assert.AreEqual(ret, false);
                ret = l.Init(2);
                Assert.AreEqual(ret, true);
                ret = l.Init(-1);
                Assert.AreEqual(ret, false);
            }
    

    光天化日编写翻译都无法透过(不可能因而编写翻译也是一种测量试验)

    三、定义类

     1.创办门锁A类库(Lock.LockA),代码如下:

        /// <summary>
        /// 门锁A
        /// </summary>
        public class LockA : ILock
        {
    
            /// <summary>
            /// 初始化
            /// </summary>
            /// <param name="password">正确密码是正奇数</param>
            /// <returns></returns>
            public bool Init(int password)
            {
                return password > 0 && (password % 2) == 1;
            }
        }
    

    2.开立门锁B类库(Lock.LockB),代码如下:

        /// <summary>
        /// 门锁B
        /// </summary>
        public class LockB : ILock
        {
            /// <summary>
            /// 初始化
            /// </summary>
            /// <param name="password">正确密码是正偶数</param>
            /// <returns></returns>
            public bool Init(int password)
            {
                return password > 0 && (password % 2) == 0;
            }
        }
    

    各自编写翻译成功后,回到测验项目,增加援引,编译通过,运转测试:

    新葡亰496net 16

    算不算TDD?

    四、主程序

    1.增添调整台项目

    2.添加Unity(5.8.6)包

    3.修改App.Config为:

    <?xml version="1.0" encoding="utf-8" ?>
    <configuration>
      <configSections>
        <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Unity.Configuration, Version=5.2.1.0, Culture=neutral, PublicKeyToken=6d32ff45e0ccc69f" />
        <!--上一些的内容网上复制过来有错误,后来查看UnityConfigurationSection的定义,复制了对应的程序集
        type="命名空间.类名,程序集"
        -->
      </configSections>
      <unity>
        <containers>
          <container name="LockA">
            <register type="Lock.ILock,Lock.Interface"  mapTo="Lock.LockA,Lock.LockA" ></register>
          </container>
          <container name="LockB">
            <register type="Lock.ILock,Lock.Interface"  mapTo="Lock.LockB,Lock.LockB"></register>
          </container>
        </containers>
      </unity>
      <startup>
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
      </startup>
    </configuration>
    

    4.援用接口

    5.Main方法如下:

            static void Main(string[] args)
            {
                var container = new UnityContainer();
                UnityConfigurationSection config = (UnityConfigurationSection)ConfigurationManager.GetSection(UnityConfigurationSection.SectionName);
                config.Configure(container, "LockA");
    
                ILock l = container.Resolve<ILock>();
                Console.WriteLine(l.Init(2));
                Console.WriteLine(l.Init(1));
                Console.WriteLine(l.Init(-1));
    
                Console.ReadKey();
            }
    

    6.复制门锁A的dll复制到运维目录

    7.运作结果如为:False、True、False,是门锁A的结果

    8.将“LockA”改成“LockB”,并将门锁B的dll复制到运营目录,运转结果为True、False、False是门锁B的结果

    算DI吧?咱都用了Unity了。

     

    至此,基本落到实处了想要的功力,以往新国酒店要追加门锁C、门锁D都没难题,唯有老栈城镇民居房制度改良成门锁E的难题没消除(推测能够经过动态修改config文件贯彻,也不知晓有未有更加好地格局)。

     

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:TDD的一点想法和实践

    关键词: