那就是职务链格局的格局动机,那正是命令方式的形式动机

情势动机
图片 1

方式动机
图片 2

格局动机
图片 3

任务链能够是一条直线、多个环只怕二个树形结构,最普遍的职责链是直线型,即沿着一条单向的链来传递请求。
链上的每一个指标都是伸手处理者,职分链形式可以将请求的处理者协会成一条链,并使请求沿着链传递,由链上的处理者对请求实行相应的拍卖,客户端无须关切请求的处理细节以及呼吁的传递,只需将请求发送到链上即可,将呼吁的发送者和伸手的处理者解耦。那正是任务链格局的格局动机。

任务链能够是一条直线、四个环或然二个树形结构,最常见的职务链是直线型,即沿着一条单向的链来传递请求。
链上的每多个对象都以伸手处理者,职分链情势能够将呼吁的处理者协会成一条链,并使请求沿着链传递,由链上的处理者对请求进行对应的处理,客户端无须关切请求的拍卖细节以及呼吁的传递,只需将请求发送到链上即可,将请求的发送者和请求的处理者解耦。那就是职务链情势的情势动机。

在软件设计中,大家通常索要向一些对象发送请求,但是并不知道请求的收信人是什么人,也不清楚被呼吁的操作是哪位,大家只需在程序运营时内定具体的央求接收者即可,此时,可以行义务令形式来开始展览统一筹划,使得请求发送者与请求接收者化解相互之间的耦合,让对象之间的调用关系越发灵活。
命令情势能够对发送者和接收者完全解耦,发送者与接收者之间从未一贯引用关系,发送请求的靶子只必要知道什么发送请求,而无需知道如何形成请求。那即是命令情势的格局动机。

情势定义
职责链形式(Chain of Responsibility
Pattern):制止请求发送者与接收者耦合在联合署名,让多少个对象都有大概接收请求,将那么些对象连接成一条链,并且沿着那条链传递请求,直到有对象处理它截至。由于英文翻译的不等,职务链格局又叫做权利链形式,它是一种对象行为型方式。
Chain of Responsibility Pattern: Avoid coupling the sender of a request
to its receiver by giving more than one object a chance to handle the
request. Chain the receiving objects and pass the request along the
chain until an object handles it.
Frequency of use: medium low
UML图
图片 4

形式定义
职责链形式(Chain of Responsibility
Pattern):幸免请求发送者与接收者耦合在一齐,让多个对象都有或者收到请求,将那些对象连接成一条链,并且沿着那条链传递请求,直到有目的处理它结束。由于英文翻译的不等,职务链情势又称作义务链格局,它是一种对象行为型格局。
Chain of Responsibility Pattern: Avoid coupling the sender of a request
to its receiver by giving more than one object a chance to handle the
request. Chain the receiving objects and pass the request along the
chain until an object handles it.
Frequency of use: medium low
UML图
图片 5

格局定义
指令方式(Command
Pattern):将多少个伸手封装为三个对象,从而使咱们可用不一致的伸手对客户开始展览参数化;对请求排队或许记录请求日志,以及扶助可收回的操作。命令情势是一种对象行为型方式,其外号为动作(Action)情势或业务(Transaction)格局。
Command Pattern: Encapsulate a request as an object, thereby letting you
parameterize clients with different requests, queue or log requests, and
support undoable operations.
Frequency of use: medium high
UML图
图片 6

形式结构
任务链方式包蕴如下角色:
Handler: 抽象处理者
ConcreteHandler: 具体处理者
Client: 客户类

格局结构
职分链方式包罗如下剧中人物:
Handler: 抽象处理者
ConcreteHandler: 具体处理者
Client: 客户类

方式组织
指令方式涵盖如下剧中人物:
Command: 抽象命令类
ConcreteCommand: 具体命令类
Invoker: 调用者
Receiver: 接收者
Client:客户类

格局分析
在职分链形式里,很多目的由每一个对象对其下家的引用而连接起来形成一条链。
恳请在这条链上传递,直到链上的某一个目的处理此呼吁停止。
发生那几个请求的客户端并不知道链上的哪二个对象最终处理这些请求,那使得系统可以在不影响客户端的事态下动态地重复协会链和分配权利。
实例:审查批准假条
某OA系统供给提供一个假条审查批准的模块,假若职工请假天数小于3天,经理能够审查批准该假条;假使职员和工人请假天数大于等于3天,小于10天,老板能够审查批准;若是职员和工人请假天数大于等于10天,小于30天,总CEO能够审查批准;假使超过30天,总COO也不可能审查批准,提醒相应的不肯新闻

形式分析
在职务链情势里,很多指标由每种指标对其下家的引用而连接起来形成一条链。
恳请在那条链上传递,直到链上的某一个对象处理此恳请停止。
产生这一个请求的客户端并不知道链上的哪三个指标最后处理这几个请求,那使得系统能够在不影响客户端的气象下动态地重新组织链和分红义务。
实例:审查批准假条
某OA系统需求提供多少个假条审查批准的模块,借使员工请假天数小于3天,经理可以审查批准该假条;要是职工请假天数大于等于3天,小于10天,首席执行官能够审查批准;纵然职工请假天数大于等于10天,小于30天,总COO能够审查批准;借使跨越30天,总老板也不能审查批准,提醒相应的不容音信

格局分析
指令情势的本质是对命令实行包装,将生出指令的义务和执行命令的职务划分开。
每贰个指令都以贰个操作:请求的一方发出请求,须要实施3个操作;接收的一方接受请求,并施行操作。
命令格局允许请求的一方和吸收的一方独立开来,使得请求的一方无需知道接收请求的一方的接口,更不用知道请求是怎么被接受,以及操作是还是不是被实践、曾几何时被实践,以及是怎么被执行的。

方式实例与分析
演示代码—加薪非要COO批?
系统布局
图片 7

方式实例与分析
以身作则代码—加薪非要首席营业官批?
系统布局
图片 8

命令格局使请求小编成为3个目的,那一个指标和此外对象一样能够被积存和传递。
命令方式的关键在于引入了画饼充饥命令接口,且发送者针对抽象命令接口编制程序,唯有完成了抽象命令接口的现实性命令才能与接收者相关联。

Manager.cs

Manager.cs

形式实例与分析
烤羊肉串引来的思想—命令情势
系统布局
图片 9

namespace ChainofResponsibilityPattern
{
    //管理者
    abstract class Manager
    {
        protected string name;
        //管理者的上级
        protected Manager superior;
        public Manager(string name)
        {
            this.name = name;
        }
        //设置管理者的上级
        public void SetSuperior(Manager superior)
        {
            this.superior = superior;
        }
        //申请请求
        abstract public void RequestApplications(Request request);
    }
}
namespace ChainofResponsibilityPattern
{
    //管理者
    abstract class Manager
    {
        protected string name;
        //管理者的上级
        protected Manager superior;
        public Manager(string name)
        {
            this.name = name;
        }
        //设置管理者的上级
        public void SetSuperior(Manager superior)
        {
            this.superior = superior;
        }
        //申请请求
        abstract public void RequestApplications(Request request);
    }
}

Command: 抽象命令类 Command.cs

Request.cs

Request.cs

namespace CommandPattern
{
    //抽象命令类
    public abstract class Command
    {
        protected Barbecuer receiver;
        public Command(Barbecuer receiver)
        {
            this.receiver = receiver;
        }
        //执行命令
        abstract public void ExecuteCommand();
    }
}
namespace ChainofResponsibilityPattern
{
    class Request
    {
        //申请类别
        private string requestType;
        public string RequestType
        {
            get { return requestType; }
            set { requestType = value; }
        }
        //申请内容
        private string requestContent;
        public string RequestContent
        {
            get { return requestContent; }
            set { requestContent = value; }
        }
        //数量
        private int number;
        public int Number
        {
            get { return number; }
            set { number = value; }
        }
    }
}
namespace ChainofResponsibilityPattern
{
    class Request
    {
        //申请类别
        private string requestType;
        public string RequestType
        {
            get { return requestType; }
            set { requestType = value; }
        }
        //申请内容
        private string requestContent;
        public string RequestContent
        {
            get { return requestContent; }
            set { requestContent = value; }
        }
        //数量
        private int number;
        public int Number
        {
            get { return number; }
            set { number = value; }
        }
    }
}

ConcreteCommand: 具体命令类 BakeMuttonCommand.cs

CommonManager.cs

CommonManager.cs

namespace CommandPattern
{
    //烤羊肉串命令
    class BakeMuttonCommand : Command
    {
        public BakeMuttonCommand(Barbecuer receiver)
            : base(receiver)
        {
        }
        public override void ExecuteCommand()
        {
            receiver.BakeMutton();
        }
    }
}
using System;

namespace ChainofResponsibilityPattern
{
    //经理
    class CommonManager : Manager
    {
        public CommonManager(string name)
            : base(name)
        {
        }
        public override void RequestApplications(Request request)
        {
            if (request.RequestType == "请假" && request.Number <= 2)
            {
                //经理所能有的权限就是可批准下属两天内的假期
                Console.WriteLine("{0}:{1} 数量{2} 被批准", name, request.RequestContent, request.Number);
            }
            else
            {
                if (superior != null)
                {
                    superior.RequestApplications(request);//其余的申请都需转到上级
                }
            }
        }
    }
}
using System;

namespace ChainofResponsibilityPattern
{
    //经理
    class CommonManager : Manager
    {
        public CommonManager(string name)
            : base(name)
        {
        }
        public override void RequestApplications(Request request)
        {
            if (request.RequestType == "请假" && request.Number <= 2)
            {
                //经理所能有的权限就是可批准下属两天内的假期
                Console.WriteLine("{0}:{1} 数量{2} 被批准", name, request.RequestContent, request.Number);
            }
            else
            {
                if (superior != null)
                {
                    superior.RequestApplications(request);//其余的申请都需转到上级
                }
            }
        }
    }
}

BakeChickenWingCommand.cs

Majordomo.cs

Majordomo.cs

namespace CommandPattern
{
    //烤鸡翅命令
    class BakeChickenWingCommand : Command
    {
        public BakeChickenWingCommand(Barbecuer receiver)
            : base(receiver)
        {
        }
        public override void ExecuteCommand()
        {
            receiver.BakeChickenWing();
        }
    }
}
using System;

namespace ChainofResponsibilityPattern
{
    //总监
    class Majordomo : Manager
    {
        public Majordomo(string name)
            : base(name)
        {
        }
        public override void RequestApplications(Request request)
        {
            if (request.RequestType == "请假" && request.Number <= 5)
            {
                //总监所能有的权限就是可批准下属一周内的假期
                Console.WriteLine("{0}:{1} 数量{2} 被批准", name, request.RequestContent, request.Number);
            }
            else
            {
                if (superior != null)
                {
                    superior.RequestApplications(request);//其余的申请都需转到上级
                }
            }
        }
    }
}
using System;

namespace ChainofResponsibilityPattern
{
    //总监
    class Majordomo : Manager
    {
        public Majordomo(string name)
            : base(name)
        {
        }
        public override void RequestApplications(Request request)
        {
            if (request.RequestType == "请假" && request.Number <= 5)
            {
                //总监所能有的权限就是可批准下属一周内的假期
                Console.WriteLine("{0}:{1} 数量{2} 被批准", name, request.RequestContent, request.Number);
            }
            else
            {
                if (superior != null)
                {
                    superior.RequestApplications(request);//其余的申请都需转到上级
                }
            }
        }
    }
}

Invoker: 调用者 Waiter.cs

GeneralManager.cs

GeneralManager.cs

using System;
using System.Collections.Generic;

namespace CommandPattern
{
    //服务员
    public class Waiter
    {
        //增加存放具体命令的容器
        private IList<Command> orders = new List<Command>();

        //设置订单
        public void SetOrder(Command command)
        {
            if (command.ToString() == "CommandPattern.BakeChickenWingCommand")
            {
                Console.WriteLine("服务员:鸡翅没有了,请点别的烧烤.");
            }
            else
            {
                orders.Add(command);
                Console.WriteLine("增加订单:" + command.ToString() + " 时间:" + DateTime.Now.ToString());
            }
        }
        //取消订单
        public void CancelOrder(Command command)
        {
            orders.Remove(command);
            Console.WriteLine("取消订单:" + command.ToString() + " 时间:" + DateTime.Now.ToString());
        }
        //通知全部执行
        public void Notify()
        {
            foreach (Command cmd in orders)
            {
                cmd.ExecuteCommand();            }
        }
    }
}
using System;

namespace ChainofResponsibilityPattern
{
    //总经理
    class GeneralManager : Manager
    {
        public GeneralManager(string name)
            : base(name)
        {
        }
        public override void RequestApplications(Request request)
        {
            if (request.RequestType == "请假")
            {
                //总经理可准许下属任意天的假期
                Console.WriteLine("{0}:{1} 数量{2} 被批准", name, request.RequestContent, request.Number);
            }
            else if (request.RequestType == "加薪" && request.Number <= 500)
            {
                Console.WriteLine("{0}:{1} 数量{2} 被批准", name, request.RequestContent, request.Number);
            }
            else if (request.RequestType == "加薪" && request.Number > 500)
            {
                Console.WriteLine("{0}:{1} 数量{2} 再说吧", name, request.RequestContent, request.Number);
            }
        }
    }
}
using System;

namespace ChainofResponsibilityPattern
{
    //总经理
    class GeneralManager : Manager
    {
        public GeneralManager(string name)
            : base(name)
        {
        }
        public override void RequestApplications(Request request)
        {
            if (request.RequestType == "请假")
            {
                //总经理可准许下属任意天的假期
                Console.WriteLine("{0}:{1} 数量{2} 被批准", name, request.RequestContent, request.Number);
            }
            else if (request.RequestType == "加薪" && request.Number <= 500)
            {
                Console.WriteLine("{0}:{1} 数量{2} 被批准", name, request.RequestContent, request.Number);
            }
            else if (request.RequestType == "加薪" && request.Number > 500)
            {
                Console.WriteLine("{0}:{1} 数量{2} 再说吧", name, request.RequestContent, request.Number);
            }
        }
    }
}

Receiver: 接收者 Barbecuer.cs

Client:客户类

Client:客户类

using System;

namespace CommandPattern
{
    //烤肉串者
    public class Barbecuer
    {
        //烤羊串
        public void BakeMutton()
        {
            Console.WriteLine("烤羊肉串!");
        }
        public void BakeChickenWing()
        {
            Console.WriteLine("烤鸡翅!");
        }
    }
}
using System;

namespace ChainofResponsibilityPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            CommonManager commonManger = new CommonManager("张经理");
            Majordomo majordomo = new Majordomo("李总监");
            GeneralManager generalManager = new GeneralManager("王总经理");
            //设置上级,完全可以根据实际需求来更改设置
            commonManger.SetSuperior(majordomo);
            majordomo.SetSuperior(generalManager);

            Request request = new Request();
            request.RequestType = "请假";
            request.RequestContent = "小菜请假";
            request.Number = 1;
            //客户端的申请都是由经理发起,但实际谁来决策由具体类来处理,客户端不知道
            commonManger.RequestApplications(request);

            Request request2 = new Request();
            request2.RequestType = "请假";
            request2.RequestContent = "小菜请假";
            request2.Number = 4;
            commonManger.RequestApplications(request2);

            Request request3 = new Request();
            request3.RequestType = "加薪";
            request3.RequestContent = "小菜请求加薪";
            request3.Number = 500;
            commonManger.RequestApplications(request3);

            Request request4 = new Request();
            request4.RequestType = "加薪";
            request4.RequestContent = "小菜请求加薪";
            request4.Number = 1000;
            commonManger.RequestApplications(request4);

            Console.Read();
        }
    }
}
using System;

namespace ChainofResponsibilityPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            CommonManager commonManger = new CommonManager("张经理");
            Majordomo majordomo = new Majordomo("李总监");
            GeneralManager generalManager = new GeneralManager("王总经理");
            //设置上级,完全可以根据实际需求来更改设置
            commonManger.SetSuperior(majordomo);
            majordomo.SetSuperior(generalManager);

            Request request = new Request();
            request.RequestType = "请假";
            request.RequestContent = "小菜请假";
            request.Number = 1;
            //客户端的申请都是由经理发起,但实际谁来决策由具体类来处理,客户端不知道
            commonManger.RequestApplications(request);

            Request request2 = new Request();
            request2.RequestType = "请假";
            request2.RequestContent = "小菜请假";
            request2.Number = 4;
            commonManger.RequestApplications(request2);

            Request request3 = new Request();
            request3.RequestType = "加薪";
            request3.RequestContent = "小菜请求加薪";
            request3.Number = 500;
            commonManger.RequestApplications(request3);

            Request request4 = new Request();
            request4.RequestType = "加薪";
            request4.RequestContent = "小菜请求加薪";
            request4.Number = 1000;
            commonManger.RequestApplications(request4);

            Console.Read();
        }
    }
}

Client:客户类

方式优缺点
职务链形式的亮点
 降低耦合度
 可简化对象的相互连接
 增强给指标指派任务的八面后珑
 扩展新的伏乞处理类很便宜
义务链形式的通病
 无法担保请求一定被接受。

系统质量将面临一定影响,而且在进展代码调节和测试时不太方便;大概会招致循环调用。

格局优缺点
职分链方式的长处
 降低耦合度
 可简化对象的互相连接
 增强给目的指派职分的灵活性
 扩展新的伸手处理类很便利
任务链情势的缺陷
 不能够保险请求一定被选取。

系统质量将碰到肯定影响,而且在展开代码调节和测试时不太便宜;大概会造成循环调用。

using System;

namespace CommandPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            //开店前的准备
            Barbecuer boy = new Barbecuer();
            Command bakeMuttonCommand1 = new BakeMuttonCommand(boy);
            Command bakeMuttonCommand2 = new BakeMuttonCommand(boy);
            Command bakeChikenWingCommand1 = new BakeChickenWingCommand(boy);
            Waiter girl = new Waiter();
            //开门营业 顾客点菜
            girl.SetOrder(bakeMuttonCommand1);
            girl.SetOrder(bakeMuttonCommand2);
            girl.SetOrder(bakeChikenWingCommand1);
            //点菜完毕,通知厨房
            girl.Notify();

            Console.Read();
        }
    }
}

情势适用条件
在以下境况下能够运用职务链形式:

有四个对象能够拍卖同四个伸手,具体哪些目的处理该请求由运维时刻自动明确。
 在不肯定钦命接收者的情况下,向几个指标中的2个付出三个请求。
 可动态钦命一组对象处理请求。

情势适用条件
在偏下情状下能够使用职分链形式:

有五个目的足以处理同一个呼吁,具体哪个目的处理该请求由运维时刻自动鲜明。
 在不明朗钦点接收者的景况下,向八个对象中的四个交付1个呼吁。
 可动态内定一组对象处理请求。

情势优缺点
指令方式的亮点
 下降系统的耦合度。
 新的命令可以很简单地到场到系统中。
 能够相比便于地设计贰个发令队列和宏命令(组合命令)。
 能够方便地贯彻对请求的Undo和Redo。

【表明与多谢】
本文,站在诸多大汉的双肩上,借鉴和引用了过多客人拥有版权的文章或撰文,在此,对前人们的贡献致谢。并还要宣布引用的始末、原作者或缘于(一些来自网络的内容笔者不可能追述本源,深表遗憾)。

【表明与谢谢】
本文,站在众多高个儿的肩头上,借鉴和引用了不少客人拥有版权的小说或撰文,在此,对前人们的贡献致谢。并同时公布引用的剧情、原我或出自(一些出自互连网的始末作者不能追述本源,深表遗憾)。

指令模式的症结

使用命令形式大概会导致一些系统有过多的实际命令类。因为针对每三个发令都急需规划三个有血有肉命令类,因而有个别系统可能必要多量切实可行命令类,那将影响命令方式的应用。

【参考文献】
《设计形式—可复用面向对象软件的底蕴》小编: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—革新既有代码的陈设》作者: 马丁 Fowler译者:候捷
中华人民共和国电力出版社
《敏捷软件开发—原则、格局与实施》作者: 罗伯特 C. 马丁 哈工业余大学学东军事和政治高校学出版社
《程序员修炼之道—从小工到学者》小编: Andrew Hunt / 大卫 Thomas电子工业出版社
《Head First 设计形式》笔者: Freeman 译者: O’Reilly Taiwan公司中国电力出版社
《设计方式之禅》 作者: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计格局纵横谈》 助教:李建忠
刘伟先生. 设计格局. 新加坡:哈工业余大学学东军事和政治大学学出版社, 二零一三.
刘伟先生. 设计方式实验和培养和演练教程. 东京(Tokyo):清华东军事和政院学出版社, 二零一三.
《大话设计格局》 小编: 程杰 武大东军事和政院学出版社
《C#图解教程》小编: 索Liss 译者: 苏林 / 朱晔 人民邮政和邮电通信出版社
《你必须精通的.NET》我: 王涛
《项目中的.NET》小编: 李天平 电子工业出版社
《Microsoft .NET集团级应用架构划设想计》小编: (美)埃斯波西托等小说 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客小编:吕震宇
http://www.cnblogs.com/terrylee 博客小编:李会军
http://www.cnblogs.com/anlyren/ 博客小编:anlyren
http://www.cnblogs.com/idior 博客笔者:idior
http://www.cnblogs.com/allenlooplee 博客作者:Allen lee
http://blog.csdn.net/ai92 博客小编:ai92
http://www.cnblogs.com/umlonline/ 博客小编:张传波
http://www.cnblogs.com/lovecherry/ 博客小编:LoveCherry

【参考文献】
《设计格局—可复用面向对象软件的底蕴》笔者: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改革既有代码的陈设》作者: 马丁 Fowler译者:候捷
中夏族民共和国电力出版社
《敏捷软件开发—原则、方式与执行》笔者: 罗伯特 C. 马丁 南开东军大学出版社
《程序员修炼之道—从小工到大方》笔者: Andrew Hunt / 戴维 Thomas电子工业出版社
《Head First 设计格局》我: Freeman 译者: O’Reilly Taiwan集团中华夏族民共和国电力出版社
《设计方式之禅》 我: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计情势纵横谈》 助教:李建忠
Liu Wei. 设计形式. 法国首都:清华大学出版社, 二零一三.
刘伟同志. 设计形式实验和培养和陶冶教程. 日本首都:哈工业余大学学东军政高校学出版社, 二零一三.
《大话设计格局》 我: 程杰 交大东军政大学学出版社
《C#图解教程》作者: 索Liss 译者: 苏林 / 朱晔 人民邮政和邮电通信出版社
《你必须知道的.NET》作者: 王涛
《项目中的.NET》小编: 李天平 电子工业出版社
《Microsoft .NET集团级应用框架结构划设想计》作者: (美)埃斯波西托等创作 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客小编:吕震宇
http://www.cnblogs.com/terrylee 博客小编:李会军
http://www.cnblogs.com/anlyren/ 博客作者:anlyren
http://www.cnblogs.com/idior 博客笔者:idior
http://www.cnblogs.com/allenlooplee 博客作者:阿伦 lee
http://blog.csdn.net/ai92 博客小编:ai92
http://www.cnblogs.com/umlonline/ 博客作者:张传波
http://www.cnblogs.com/lovecherry/ 博客小编:Love切莉

方式适用条件
在以下情状下能够动用命令方式:
 系统须要将呼吁调用者和呼吁接收者解耦,使得调用者和接收者不直接互动。
 系统需求在分化的日子钦赐请求、将呼吁排队和执行请求。
 系统必要帮助命令的吊销(Undo)操作和死灰复燃(Redo)操作。
 系统供给将一组操作结合在共同,即辅助宏命令。

【证明与多谢】
本文,站在无数巨人的肩膀上,借鉴和引用了累累别人拥有版权的文章或撰文,在此,对前人们的孝敬致谢。并同时发表引用的内容、原我或出自(一些来源网络的情节本人不或许追述本源,深表遗憾)。

【参考文献】
《设计格局—可复用面向对象软件的根底》小编: [美] 埃里克h Gamma / RichardHelm / Ralph Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改革既有代码的统一筹划》我: 马丁 Fowler译者:候捷
中中原人民共和国电力出版社
《敏捷软件开发—原则、格局与实践》笔者: 罗Bert C. 马丁 浙大东军事和政院学出版社
《程序员修炼之道—从小工到大家》小编: Andrew Hunt / David Thomas电子工业出版社
《Head First 设计方式》小编: Freeman 译者: O’Reilly Taiwan集团中国电力出版社
《设计格局之禅》 我: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计方式纵横谈》 教师:李建忠
刘伟先生. 设计情势. 北京:哈工业余大学学东军事和政治高校学出版社, 二零一二.
刘伟(Liu-Wei). 设计情势实验和培养和锻练教程. 新加坡:北大高校出版社, 二〇一三.
《大话设计格局》 小编: 程杰 复旦东军大学出版社
《C#图解教程》小编: 索Liss 译者: 苏林 / 朱晔 人民邮电出版社
《你不能够不领会的.NET》笔者: 王涛
《项目中的.NET》笔者: 李天平 电子工业出版社
《Microsoft .NET公司级应用架构划设想计》小编: (美)埃斯波西托等创作 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客笔者:吕震宇
http://www.cnblogs.com/terrylee 博客作者:李会军
http://www.cnblogs.com/anlyren/ 博客我:anlyren
http://www.cnblogs.com/idior 博客小编:idior
http://www.cnblogs.com/allenlooplee 博客我:Allen lee
http://blog.csdn.net/ai92 博客小编:ai92
http://www.cnblogs.com/umlonline/ 博客作者:张传波
http://www.cnblogs.com/lovecherry/ 博客作者:乐福Cherry

相关文章