命令形式能够对发送者和接收者完全解耦,并使请求沿着链传递

形式动机
图片 1

格局动机
图片 2

情势动机
图片 3

任务链可以是一条直线、三个环恐怕2个树形结构,最广泛的职分链是直线型,即沿着一条单向的链来传递请求。
链上的每贰个目的都是请求处理者,职务链情势能够将请求的处理者协会成一条链,并使请求沿着链传递,由链上的处理者对请求实行对应的拍卖,客户端无须关怀请求的处理细节以及呼吁的传递,只需将请求发送到链上即可,将请求的发送者和请求的处理者解耦。那正是职务链情势的情势动机。

职务链能够是一条直线、多少个环恐怕二个树形结构,最广大的任务链是直线型,即沿着一条单向的链来传递请求。
链上的每个目的皆以伸手处理者,职分链格局能够将请求的处理者组织成一条链,并使请求沿着链传递,由链上的处理者对请求进行相应的拍卖,客户端无须关注请求的处理细节以及呼吁的传递,只需将请求发送到链上即可,将请求的发送者和伸手的处理者解耦。那正是职务链方式的方式动机。

在软件设计中,我们平时索要向一些对象发送请求,可是并不知道请求的收信人是哪个人,也不明白被呼吁的操作是哪个,我们只需在程序运维时钦点具体的请求接收者即可,此时,能够选取命令方式来开始展览规划,使得请求发送者与请求接收者化解相互之间的耦合,让对象之间的调用关系更为灵活。
指令情势能够对发送者和接收者完全解耦,发送者与接收者之间没有一贯引用关系,发送请求的目的只需求掌握怎么发送请求,而不要知道怎么完结请求。那正是命令方式的形式动机。

情势定义
任务链格局(Chain of Responsibility
帕特tern):制止请求发送者与接收者耦合在同步,让四个对象都有或许接受请求,将那个对象连接成一条链,并且沿着那条链传递请求,直到有对象处理它甘休。由于英文翻译的两样,职责链方式又称作义务链方式,它是一种对象行为型方式。
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):将3个伸手封装为3个目的,从而使大家可用分歧的请求对客户开始展览参数化;对请求排队或然记录请求日志,以及扶助可收回的操作。命令情势是一种对象行为型情势,其小名为动作(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系统需求提供1个假条审查批准的模块,要是职工请假天数小于3天,首席执行官能够审查批准该假条;假若职工请假天数大于等于3天,小于10天,老总能够审查批准;假使职工请假天数大于等于10天,小于30天,总老总能够审查批准;假诺跨越30天,总老董也无法审查批准,提示相应的不容音信

方式分析
在职务链情势里,很多对象由每3个对象对其下家的引用而连接起来形成一条链。
呼吁在那条链上传递,直到链上的某二个目标处理此呼吁结束。
发出那一个请求的客户端并不知道链上的哪2个目的最终处理那一个请求,那使得系统能够在不影响客户端的意况下动态地重复协会链和分配权利。
实例:审查批准假条
某OA系统需求提供1个假条审批的模块,倘使职工请假天数小于3天,CEO能够审批该假条;如果职工请假天数大于等于3天,小于10天,主管能够审批;假设员工请假天数大于等于10天,小于30天,总老板能够审查批准;假如超越30天,总首席营业官也无法审批,提醒相应的不容新闻

格局分析
指令方式的真面目是对命令进行李包裹装,将生出命令的权力和义务和执行命令的权利分开开。
每五个发令都以三个操作:请求的一方发出请求,须求进行2个操作;接收的一方接受请求,并执行操作。
命令格局允许请求的一方和采纳的一方独立开来,使得请求的一方无需知道接收请求的一方的接口,更不要知道请求是怎么被选用,以及操作是或不是被实施、什么时候被实践,以及是怎么被执行的。

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

格局实例与分析
演示代码—加薪非要总经理批?
系统布局
图片 8

指令格局使请求笔者成为1个对象,这么些目的和任何对象一样能够被储存和传递。
指令形式的关键在于引入了抽象命令接口,且发送者针对抽象命令接口编制程序,只有完成了抽象命令接口的切实可行命令才能与接收者相关联。

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

方式适用条件
在偏下情状下得以动用任务链格局:

有三个对象足以处理同3个呼吁,具体哪个指标处理该请求由运营时刻自动鲜明。
 在不强烈钦定接收者的情景下,向五个指标中的贰个付出贰个呼吁。
 可动态钦赐一组对象处理请求。

格局适用条件
在偏下景况下能够动用任务链形式:

有多少个对象能够处理同四个呼吁,具体哪个指标处理该请求由运维时刻自动分明。
 在不明朗钦赐接收者的意况下,向三个目的中的三个交给二个请求。
 可动态钦定一组对象处理请求。

方式优缺点
命令情势的亮点
 下落系统的耦合度。
 新的指令能够很容易地投入到系统中。
 能够相比较简单地规划三个命令队列和宏命令(组合命令)。
 能够一本万利地促成对请求的Undo和Redo。

【注明与感激】
本文,站在众多巨人的肩膀上,借鉴和引用了好多外人拥有版权的著述或撰文,在此,对前人们的进献致谢。并还要发表引用的始末、原来的著笔者或缘于(一些来自网络的内容作者不恐怕追述本源,深表遗憾)。

【声明与多谢】
本文,站在许多高个儿的肩头上,借鉴和引用了无数客人拥有版权的著作或撰文,在此,对前人们的进献致谢。并还要宣布引用的情节、原来的文章者或缘于(一些源于互连网的始末小编无法追述本源,深表遗憾)。

指令情势的老毛病

使用命令格局可能会造成有些系统有过多的切切实实命令类。因为针对每1个发令都亟需统筹八个切实可行命令类,由此有个别系统或者须求多量实际命令类,那将震慑命令情势的采用。

【参考文献】
《设计格局—可复用面向对象软件的根基》小编: [美] 埃里克h Gamma / RichardHelm / Ralph Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改革既有代码的统一筹划》小编: 马丁 Fowler译者:候捷
中华夏族民共和国电力出版社
《敏捷软件开发—原则、情势与实践》小编: 罗伯特 C. 马丁 哈工大东军事和政院学出版社
《程序员修炼之道—从小工到大方》作者: Andrew Hunt / 戴维 托马斯电子工业出版社
《Head First 设计情势》小编: Freeman 译者: O’Reilly Taiwan公司中夏族民共和国电力出版社
《设计形式之禅》 笔者: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计格局纵横谈》 助教:李建忠
刘伟同志. 设计形式. 东京:北大东军大学出版社, 贰零壹壹.
Liu Wei. 设计方式实验和培养和练习教程. Hong Kong:哈工业余大学学东军事和政院学出版社, 二〇一二.
《大话设计形式》 作者: 程杰 清华东军事和政院学出版社
《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 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改革既有代码的规划》我: Martin Fowler译者:候捷
中中原人民共和国电力出版社
《敏捷软件开发—原则、情势与执行》小编: 罗伯特 C. Martin 北大东军事和政院学出版社
《程序员修炼之道—从小工到学者》小编: Andrew Hunt / 戴维 Thomas电子工业出版社
《Head First 设计情势》小编: 弗里曼 译者: O’Reilly Taiwan公司中国电力出版社
《设计格局之禅》 小编: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计格局纵横谈》 教师:李建忠
刘伟先生. 设计情势. 东京(Tokyo):复旦东军政大学学出版社, 二零一二.
刘伟(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/ 博客作者:LoveCherry

方式适用条件
在以下景况下得以选取命令格局:
 系统必要将请求调用者和呼吁接收者解耦,使得调用者和接收者不直接互动。
 系统须要在分歧的时日钦命请求、将请求排队和履行请求。
 系统需求辅助命令的吊销(Undo)操作和还原(Redo)操作。
 系统需求将一组操作结合在联合署名,即帮助宏命令。

【注脚与多谢】
本文,站在不少壮汉的双肩上,借鉴和引用了许多客人拥有版权的创作或撰文,在此,对前人们的贡献致谢。并还要公告引用的剧情、原版的书文者或出自(一些出自网络的内容本人不大概追述本源,深表遗憾)。

【参考文献】
《设计形式—可复用面向对象软件的根底》作者: [美] 埃里克h Gamma / RichardHelm / Ralph Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—革新既有代码的宏图》我: 马丁 福勒译者:候捷
中华夏族民共和国电力出版社
《敏捷软件开发—原则、情势与实施》作者: 罗Bert C. 马丁 北大大学出版社
《程序员修炼之道—从小工到大家》小编: Andrew Hunt / 大卫 Thomas电子工业出版社
《Head First 设计方式》作者: Freeman 译者: O’Reilly Taiwan公司中夏族民共和国电力出版社
《设计方式之禅》 我: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计情势纵横谈》 教师:李建忠
刘伟(Liu-Wei). 设计格局. 新加坡:哈工大东军事和政院学出版社, 二〇一一.
Liu Wei. 设计情势实验和培养和锻练教程. 新加坡:北大东军事和政院学出版社, 二零一二.
《大话设计格局》 小编: 程杰 南开大学出版社
《C#图解教程》小编: 索利斯 译者: 苏林 / 朱晔 人民邮政和邮电通讯出版社
《你不可能不驾驭的.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

相关文章