();
45 | string[] elements = sentense.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
46 | foreach (string element in elements)
47 | {
48 | string[] words = element.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
49 | foreach (string word in words)
50 | {
51 | expressions.Add(new WordExpression(word));
52 | }
53 | expressions.Add(new SymbolExpression("."));
54 | }
55 | foreach (IExpression expression in expressions)
56 | {
57 | expression.Interpret(sb);
58 | }
59 | return sb.ToString();
60 | }
61 | }
62 |
63 | public class SymbolExpression : IExpression
64 | {
65 | private string _value;
66 |
67 | public SymbolExpression(string value)
68 | {
69 | _value = value;
70 | }
71 |
72 | public void Interpret(StringBuilder sb)
73 | {
74 | switch (_value)
75 | {
76 | case ".":
77 | sb.Append("。");
78 | break;
79 |
80 | default:
81 | break;
82 | }
83 | }
84 | }
85 |
86 | //具体翻译类
87 | public class WordExpression : IExpression
88 | {
89 | private string _value;
90 |
91 | public WordExpression(string value)
92 | {
93 | _value = value;
94 | }
95 |
96 | public void Interpret(StringBuilder sb)
97 | {
98 | sb.Append(ChineseEnglishDict.GetEnglish(_value.ToLower()));
99 | }
100 | }
101 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/解释者模式/Program.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :Program
4 | // created by 朱锦润
5 | // created time 2017/07/08 15:38:57
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.解释者模式
10 | {
11 | public class Program : OpenDesign
12 | {
13 | public override void Open()
14 | {
15 | string englist = "This is an apple.";
16 | string chinese = Translator.Translate(englist);
17 | Console.WriteLine(chinese);
18 | Console.Read();
19 | }
20 | }
21 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/设计摘要/创建性模式.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | 创建性模式
6 |
7 |
8 |
9 | 返回顶部
10 |
11 |
12 |
13 | 创建型模式就是用来创建对象的模式，抽象了实例化的过程。所有的创建型模式都有两个共同点。
14 | 第一，它们都将系统使用哪些具体类的信息封装起来；
15 | 第二，它们隐藏了这些类的实例是如何被创建和组织的。
16 | 创建型模式包括 单例模式、简单工厂、工厂方法模式、抽象工厂模式、建造者模式
17 | 和原型模式
18 |
19 |
20 |
21 | - 单例模式：解决的是实例化对象的个数问题，比如抽象工厂中的工厂、对象池等，除了Singleton之外，其他创建型模式解决的都是new所带来的耦合关系
22 | - 抽象工厂：创建一系列相互依赖对象，并在运行时改变系列
23 | - 工厂方法：创建单个对象，并在运行时改变
24 | - 原型模式：通过拷贝原型来创建新的对象
25 | - 建造者：创建操作对象，并根据操作对象进行生成
26 |
27 |
29 |
单例模式
30 |
31 | 介绍：
32 | 确保一个类只有一个实例,并提供一个全局访问点。
33 | 产生原因：
34 | 操作系统中只能有一个任务管理器,操作文件时,同一时间内只允许一个实例对其操作等,既然现实生活中有这样的应用场景,
35 | 自然在软件设计领域必须有这样的解决方案了(因为软件设计也是现实生活中的抽象)，所以也就有了单例模式了。
36 | 常用场景：应用中有对象需要是全局的且唯一。
37 | 选择关键点：一个对象在应用中出现多个实例是否会引起逻辑上或者是程序上的错误。
38 | 逆鳞：在以为是单例的情况下，却产生了多个实例。
39 |
40 |
42 |
简单工厂
43 |
44 | 介绍：
45 | 降低对象之间的耦合度。
46 | 备注：
47 | 继承抽象类，由工厂类判断传递参数，来决定实例化那些类。
48 | 常用场景：需要在一堆产品中选择其中一个产品。
49 | 选择关键点：一种产品是否可根据某个参数决定它的种类。
50 | 逆鳞：工厂类不能正常工作。
51 |
52 |
54 |
工厂方法
55 |
56 | 介绍：
57 | 工厂模式把实现具体产品创建推迟到子类中，此时工厂类不再负责所有产品的创建，而只是给出具体工厂必须实现的接口。
58 | 这样工厂方法模式就可以允许系统不修改工厂类逻辑的情况下来添加新产品。
59 | 备注：
60 | 抽象工厂类，定义抽象方法。子类继承抽象工厂，实现该方法。调用的时候，使用抽象类实例继承的子类，再去调用子类的方法。
61 | 常用场景：（1）希望工厂与产品的种类对客户端保持透明，给客户端提供一致的操作。（2）不同的工厂和产品可以提供客户端不同的服务或功能。
62 | 选择关键点：工厂类和产品类是否是同生同灭的关系
63 | 逆鳞：-
64 |
65 |
67 |
抽象工厂
68 |
69 | 介绍：
70 | 提供一个创建产品的接口来负责创建相关或依赖的对象，而不具体明确指定具体类。
71 | 抽象工厂允许客户使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么。这样客户就可以从具体产品中被解耦。
72 | 备注：
73 | 与工厂方法类似，定义一组抽象方法
74 | 常用场景：需要一个接口可以提供一个产品组，且不必知道产品的具体种类。
75 | 选择关键点：产品组是否需要一起提供，且是否有一致的接口。
76 | 逆鳞：-
77 |
78 |
80 |
建造者
81 |
82 | 介绍：
83 | 在软件系统中，有时需要创建一个复杂对象，并且这个复杂对象由其各部分子对象通过一定的步骤组合而成
84 | 备注：
85 | 操作类写步骤，参数抽象，具体实现在参数抽象中
86 | 常用场景：需要构建一批构建过程相同但表示不同的产品，而构建过程非常复杂。
87 | 选择关键点：各个产品的构建过程是否相同
88 | 逆鳞：指挥者不能正常工作
89 |
90 |
92 |
原型
93 |
94 | 介绍：
95 | 只创建一个类实例对象，如果后面需要更多这样的实例，可以通过对原来对象拷贝一份来完成创建，这样在内存中不需要创建多个相同的类实例，从而减少内存的消耗和达到类实例的复用
96 | 备注：
97 | 只有一个实例，以后创建需要从这个实例进行拷贝。分为深拷贝和浅拷贝
98 | 常用场景：需要在运行时动态的创建指定实例种类的对象，或是需要复用其状态
99 | 选择关键点：创建出来的对象是否可以立即投入使用
100 | 逆鳞：在以为是深度拷贝的情况下，却未实现深度拷贝
101 |
102 |
9 | 返回顶部
10 |
11 |
12 |
13 | 结构型模式，顾名思义讨论的是类和对象的结构，主要用处理类或对象的组合。
14 | 它包括两种类型：
15 | 一、类结构型模式，指的是采用继承机制来组合接口或实现；
16 | 二、对象结构型模式，指的是通过组合对象的方式来实现新的功能。
17 | 包括：适配器模式、桥接模式、装饰者模式、组合模式、外观模式、
18 | 享元模式、代理模式
19 |
20 |
21 |
22 | - 适配器模式注重转换接口，将不吻合的接口适配对接
23 | - 桥接模式注重分离接口与其实现，支持多维度变化
24 | - 组合模式注重统一接口，将“一对多”的关系转换为“一对一”的关系
25 | - 装饰者模式注重稳定接口，在此前提下为对象扩展功能
26 | - 外观模式注重简化接口，简化组件系统与外部客户程序的依赖关系
27 | - 享元模式注重保留接口，在内部使用共享技术对对象存储进行优化
28 | - 代理模式注重假借接口，增加间接层来实现灵活控制
29 |
30 |
32 |
适配器模式
33 |
34 | 介绍：
35 | 把一个类的接口变换成客户端所期待的另一种接口，从而使原本接口不匹配而无法一起工作的两个类能够在一起工作。
36 | 适配器模式有类的适配器和对象的适配器两种形式
37 | 备注：
38 | 目标角色是接口，源角色是抽象类。需要根据适配器把，源角色转换为目标角色。适配器类继承抽象类、源角色接口。并返回源角色
39 | 目标角色是方法，源角色是方法。适配器类继承目标角色，内部返回源角色
40 | 常用场景：需要使用一个类的功能，但是该类的接口不符合使用场合要求的接口，可使用定制适配器，又或者是有一个接口定义的行为过多，则可以定义一个缺省适配器，让子类选择性的覆盖适配器的方法。
41 | 选择关键点：定制适配器的选择关键点在于是否有更加优良的替代方案，缺省适配器的选择关键点在于接口中的方法是否可以不全部提供，且都有缺省方案。
42 | 逆鳞：-
43 |
44 |
46 |
桥接模式
47 |
48 | 介绍：
49 | 抽象化和实现部分在一起，桥接模式的目的就是使两者分离，根据面向对象的封装变化的原则，我们可以把实现部分的变化（也就是遥控器功能的变化）封装到另外一个类中
50 | 备注：
51 | 重写抽象类中某一个方法，派生类继承抽象类，在派生类重写该方法，实例化的时候，实例派生类
52 | 常用场景：一个对象有多个维度的变化，需要将这些维度抽离出来，让且独立变化。
53 | 选择关键点：是否可以将对象拆分成多个不相关的维度。
54 | 逆鳞：-
55 |
56 |
58 |
装饰器模式
59 |
60 | 介绍：
61 | 装饰者模式来动态地给一个对象添加额外的职责。
62 | 装饰者模式以对客户透明的方式动态地给一个对象附加上更多的责任，装饰者模式相比生成子类可以更灵活地增加功能
63 | 备注：
64 | 抽象类派生一个装饰类，装饰类派生不同的方法。如果有需要就重写方法，没有需要就base执行。调用的时候，装饰类初始化装饰派生类
65 | 常用场景：一个类需要动态的添加功能，且这些功能可以相互叠加
66 | 选择关键点：添加的功能是否要动态组装
67 | 逆鳞：-
68 |
69 |
71 |
组合模式
72 |
73 | 介绍：
74 | 组合模式允许你将对象组合成树形结构来表现”部分-整体“的层次结构，使得客户以一致的方式处理单个对象以及对象的组合
75 | 组合模式实现的最关键的地方是——简单对象和复合对象必须实现相同的接口。这就是组合模式能够将组合对象和简单对象进行一致处理的原因。
76 | 备注：
77 | 分为透明模式和安全模式，透明模式所有都遵循一个接口，安全模式会在派生类添加额外方法实现。
78 | 常用场景：当有一个结构可以组合成树形结构，且需要向客户端提供一致的操作接口，使得客户端操作忽略简单元素与复杂元素
79 | 选择关键点：对外提供一致操作接口的结构是否可以转化为树形结构。
80 | 逆鳞：结构不稳定或结构中的节点有递归关系。
81 |
82 |
84 |
外观模式
85 |
86 | 介绍：
87 | 外观模式提供了一个统一接口，用来访问子系统的一群接口。外观定义了一个高级接口，让子系统更容易接受。
88 | 外观模式的实现核心主要是——由外观类去保存各个子系统的引用，实现由一个统一的外观类去包装多个子系统类，然而客户端只需要引用这个外观类，然后由外观类来调用各个子系统中的方法
89 | 备注：
90 | 就是把多种方法，组合成一个任务链，访问只需要访问任务链即可。任务链内部自动添加其他任务
91 | 常用场景：一个子系统需要对外提供服务
92 | 选择关键点：子系统对外提供服务是否需要依赖很多的类
93 | 逆鳞：子系统对外提供的服务的变化或子系统本身的不稳定
94 |
95 |
97 |
享元模式
98 |
99 | 介绍：
100 | 运用共享技术有效地支持大量细粒度的对象。享元模式可以避免大量相似类的开销，
101 | 在软件开发中如果需要生成大量细粒度的类实例来表示数据，如果这些实例除了几个参数外基本上都是相同的，这时候就可以使用享元模式来大幅度减少需要实例化类的数量。
102 | 备注：
103 | 如果对象只有某些字段不同，可以使用。将不同的字段存储，然后 返回同一个对象。
104 | 常用场景：一些状态相同的对象被大量的重复使用
105 | 选择关键点：被共享的对象是否可以将外部状态提取出来
106 | 逆鳞：没有将外部状态提取完全
107 |
108 |
110 |
代理模式
111 |
112 | 介绍：
113 | 就是给某一个对象提供一个代理，并由代理对象控制对原对象的引用。
114 | 在一些情况下，一个客户不想或者不能直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。例如电脑桌面的快捷方式就是一个代理对象，快捷方式是它所引用的程序的一个代理。
115 | 备注：
116 | 把多种操作封装成一个地方，然后供客户端调用
117 | 常用场景：需要修改或屏蔽某一个或若干个类的部分功能，复用另外一部分功能，可使用静态代理，若是需要拦截一批类中的某些方法，在方法的前后插入一些一致的操作，假设这些类有一致的接口，可使用动态代理。
118 | 选择关键点：静态代理选择的关键点是是否需要复用被代理的部分功能，动态代理选择的关键点在于能否在将被代理的这一批类当中，找出相同的切入点。
119 | 逆鳞：切入点的不稳定
120 |
121 |
9 | 返回顶部
10 |
11 |
12 | 行为型模式是对在不同对象之间划分责任和算法的抽象化。行为模式不仅仅关于类和对象，还关于它们之间的相互作用。行为型模式又分为类的行为模式和对象的行为模式两种。
13 |
14 |
15 | - 类的行为模式——使用继承关系在几个类之间分配行为。
16 | - 对象的行为模式——使用对象聚合的方式来分配行为。
17 |
18 |
33 |
34 | - 模板方法模式：封装算法结构，定义算法骨架，支持算法子步骤变化。
35 | - 命令模式：注重将请求封装为对象，支持请求的变化，通过将一组行为抽象为对象，实现行为请求者和行为实现者之间的解耦。
36 | - 迭代器模式：注重封装特定领域变化，支持集合的变化，屏蔽集合对象内部复杂结构，提供客户程序对它的透明遍历。
37 | - 观察者模式：注重封装对象通知，支持通信对象变化，实现对象状态改变，通知依赖它的对象并更新。
38 | - 中介者模式：注重封装对象见的交互，通过封装一系列对象之间的复杂交互，使他们不需要显示相互引用，实现解耦。
39 | - 状态模式：注重封装与状态相关的行为，支持状态的变化，通过封装对象状态，从而在其内部状态改变时改变它的行为。
40 | - 策略模式：注重封装算法，支持算法的变化，通过封装一系列算法，从而可以随时独立于客户替换算法。
41 | - 责任链模式：注重封装对象责任，支持责任的变化，通过动态构建职责连，实现事务处理。
42 | - 访问者模式：注重封装对象操作变化，支持在运行时为类结构添加新的操作，在类层次结构中在不改变各类的前提下定义作用于这些类实现的新的操作。
43 | - 备忘录模式：注重封装对象状态变化，支持状态保存，恢复
44 | - 解释器模式：注重封装特定领域变化，支持领域问题的频繁变化，将特定领域的问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。
45 |
46 |
48 |
模板方式模式
49 |
50 | 介绍：
51 | 在一个抽象类中定义一个操作算法的骨架，将一些步骤延迟到子类中去实现。
52 | 备注：
53 | 定不变的封装到抽象类中，需要改变的在子类中去实现。
54 | 常用场景：一批子类的功能有可提取的公共算法骨架
55 | 选择关键点：算法骨架是否牢固
56 | 逆鳞：-
57 |
58 |
60 |
命令模式
61 |
62 | 介绍：
63 | 命令模式是把一个操作或者行为抽象为一个对象中，通过对命令的抽象化来使得发出命令的责任和执行命令的责任分隔开。
64 | 备注：
65 | 将命令的接受者、发送者、具体命令、执行要求分开。具体命令抽象
66 | 常用场景：行为的请求者与行为的处理者耦合度过高
67 | 选择关键点：请求者是否不需要关心命令的执行只知道接受者
68 | 逆鳞：命令种类的无限增长
69 |
70 |
72 |
迭代器模式
73 |
74 | 介绍：
75 | 迭代器模式提供了一种方法顺序访问一个聚合对象（理解为集合对象）中各个元素，而又无需暴露该对象的内部表示，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。
76 | 备注：
77 | 聚合对象，如需要操作。则额外建立一个迭代器类。对集合进行操作处理
78 |
79 |
81 |
观察者模式
82 |
83 | 介绍：
84 | 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己的行为。
85 | 备注：
86 | 信息传递机制进行解耦操作，传递的均是信息接口
87 | 常用场景：需要将观察者与被观察者解耦或是观察者的种类不确定
88 | 选择关键点：观察者与被观察者是否是多对一的关系
89 | 逆鳞：观察者之间有过多的细节依赖
90 |
91 |
93 |
中介者模式
94 |
95 | 介绍：
96 | 定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为
97 | 备注：
98 | 禁止类之间相互交互，封装个各类之间的行为
99 | 常用场景：一个系列的对象交互关系十分复杂
100 | 选择关键点：复杂的交互关系是否有共性可被中介者承担
101 | 逆鳞：中介者无法工作
102 |
103 |
105 |
状态模式
106 |
107 | 介绍：
108 | 允许一个对象在其内部状态改变时自动改变其行为，对象看起来就像是改变了它的类。
109 | 备注：
110 | 由于状态的改变，会改变派生类，产生不同的重载方法。
111 | 常用场景：一个对象在多个状态下行为不同，且这些状态可互相转换
112 | 选择关键点：这些状态是否经常在运行时需要在不同的动态之间相互切换
113 | 逆鳞：-
114 |
115 |
117 |
策略模式
118 |
119 | 介绍：
120 | 策略模式是针对一组算法，将每个算法封装到具有公共接口的独立的类中，从而使它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。
121 | 备注：
122 | 将方法或者算法，抽象成类，有区别的算法对这个类进行继承。然后多态去实现
123 | 常用场景：算法或策略需要经常替换
124 | 选择关键点：客户端是否依赖于某一个或若干个具体的策略
125 | 逆鳞：-
126 |
127 |
129 |
责任链模式
130 |
131 | 介绍：
132 | 某个请求需要多个对象进行处理，从而避免请求的发送者和接收之间的耦合关系。将这些对象连成一条链子，并沿着这条链子传递该请求，直到有对象处理它为止。
133 | 备注：
134 | 审批人抽象，派生类中定义上级人员。调用时，制定上级人员。当请求不满足时，根据自动跳转上级人员。调用从最低开始。
135 | 常用场景：一个请求的处理需要多个对象当中的一个或几个协作处理。
136 | 选择关键点：对于每一个请求是否每个处理的对象都需要一次处理机会。
137 | 逆鳞：-
138 |
139 |
141 |
访问者模式
142 |
143 | 介绍：
144 | 数据结构的每一个节点都可以接受一个访问者的调用，此节点向访问者对象传入节点对象，而访问者对象则反过来执行节点对象的操作。
145 | 备注：
146 | 真个数据结构的方法与数据结构分离，定义访问类去找他的方法。
147 | 常用场景：作用于一个数据结构之上的操作经常变化
148 | 选择关键点：数据结构是否稳定以及操作是否经常变化
149 | 逆鳞：数据结构的不稳定
150 |
151 |
153 |
备忘录模式
154 |
155 | 介绍：
156 | 在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可以把该对象恢复到原先的状态。
157 | 备注：
158 | 对象保存静态，可用list进行扩展，类似于撤消操作
159 | 常用场景：需要在对象的外部保存该对象的内部状态
160 | 选择关键点：是否可以在必要的时候捕捉到对象的内部状态
161 | 逆鳞：大对象的备份
162 |
163 |
165 |
解释器模式
166 |
167 | 介绍:
168 | 解释器模式描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。
169 | 备注：
170 | 使用键值对，转换对应的语言
171 | 常用场景：有一种语言被频繁的使用
172 | 选择关键点：被频繁使用的语言是否可用文法表示
173 | 逆鳞：语言的规则无限制增长或规则十分不稳定
174 |
175 |
9 | 返回顶部
10 |
11 | 设计原则
12 |
13 | 使用设计模式的根本原因是适应变化，提高代码复用率，使软件更具有可维护性和可扩展性。并且，在进行设计的时候，
14 | 也需要遵循以下几个原则：单一职责原则、开闭原则、里氏替换原则、依赖倒置原则、接口隔离原则、合成复用原则、迪米特法则
15 | 下面就分别介绍每种设计原则。
16 |
17 |
18 |
单一职责原则
19 |
20 | 说明：
21 | 就一个类而言，应该只有一个引起它变化的原因。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会影响到其他的职责，另外
22 | 把多个职责耦合在一起，也会影响复用性。
23 | 理解：
24 | 一个类就管一种事情
25 |
26 |
28 |
开闭原则
29 |
30 | 说明：
31 | 开闭原则即OCP（Open-Closed Principle缩写）原则，该原则强调的是：一个软件实体（指的类、函数、模块等）应该对扩展开放，对修改关闭。
32 | 即每次发生变化时，要通过添加新的代码来增强现有类型的行为，而不是修改原有的代码。
33 | 符合开闭原则的最好方式是提供一个固有的接口，然后让所有可能发生变化的类实现该接口，让固定的接口与相关对象进行交互。
34 | 理解：
35 | 少改写好的代码
36 |
37 |
39 |
里氏替换原则
40 |
41 | 说明：
42 | Liskov Substitution Principle,LSP（里氏代替原则）指的是子类必须替换掉它们的父类型。
43 | 也就是说，在软件开发过程中，子类替换父类后，程序的行为是一样的。
44 | 只有当子类替换掉父类后，此时软件的功能不受影响时，父类才能真正地被复用，而子类也可以在父类的基础上添加新的行为。
45 | 理解：
46 | 父类要保证通用性
47 |
48 |
50 |
依赖倒置原则
51 |
52 | 说明：
53 | 依赖倒置（Dependence Inversion Principle, DIP）原则指的是抽象不应该依赖于细节，细节应该依赖于抽象，
54 | 也就是提出的 “面向接口编程，而不是面向实现编程”。这样可以降低客户与具体实现的耦合。
55 | 理解：
56 | 方法出一个接口，接口具体实现的方法单说
57 |
58 |
60 |
接口隔离原则
61 |
62 | 说明：
63 | 接口隔离原则（Interface Segregation Principle, ISP）指的是使用多个专门的接口比使用单一的总接口要好。
64 | 也就是说不要让一个单一的接口承担过多的职责，而应把每个职责分离到多个专门的接口中，进行接口分离。过于臃肿的接口是对接口的一种污染。
65 | 理解：
66 | 跟单一职责相似，一个接口就管一种事
67 |
68 |
70 |
合成复用原则
71 |
72 | 说明：
73 | 合成复用原则（Composite Reuse Principle, CRP）就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分。
74 | 新对象通过向这些对象的委派达到复用已用功能的目的。简单地说，就是要尽量使用合成/聚合，尽量不要使用继承。
75 | 要使用好合成复用原则，首先需要区分”Has—A”和“Is—A”的关系。
76 | “Is—A”是指一个类是另一个类的“一种”，是属于的关系。
77 | “Has—A”则不同，它表示某一个角色具有某一项责任。
78 | 理解：
79 | 如果你确定两件对象之间是is-a的关系，那么此时你应该使用继承；比如菱形、圆形和方形都是形状的一种，那么他们都应该从形状类继承而不是聚合。
80 | 如果你确定两件对象之间是has-a的关系，那么此时你应该使用聚合；比如电脑是由显示器、CPU、硬盘等组成的，
81 | 那么你应该把显示器、CPU、硬盘这些类聚合成电脑类，而不是从电脑类继承。
82 | 就是拼方法实现
83 |
84 |
86 |
迪米特法则
87 |
88 | 迪米特法则（Law of Demeter，LoD）又叫最少知识原则（Least Knowledge Principle，LKP），指的是一个对象应当对其他对象有尽可能少的了解。
89 | 也就是说，一个模块或对象应尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立，这样当一个模块修改时，影响的模块就会越少，扩展起来更加容易。
90 | 关于迪米特法则其他的一些表述有：只与你直接的朋友们通信；不要跟“陌生人”说话。
91 |
92 |
设计模式列表
95 |
100 |
101 |
--------------------------------------------------------------------------------
/HE23DesignPatterns/访问者模式/Client.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :Client
4 | // created by 朱锦润
5 | // created time 2017/07/08 14:23:22
6 | //--------------------------------------------
7 | using System;
8 | using System.Collections;
9 |
10 | namespace DesignMethod.访问者模式
11 | {
12 | //抽象访问者
13 | public interface IVistor
14 | {
15 | void Visit(ElementA a);
16 |
17 | void Visit(ElementB b);
18 | }
19 |
20 | //具体访问者
21 | public class ConcreteVistor : IVistor
22 | {
23 | //再去调用元素
24 | public void Visit(ElementA a)
25 | {
26 | a.Print();
27 | }
28 |
29 | public void Visit(ElementB b)
30 | {
31 | b.Print();
32 | }
33 | }
34 |
35 | //抽象元素角色
36 | public abstract class Element
37 | {
38 | public abstract void Accept(IVistor vistor);
39 |
40 | public abstract void Print();
41 | }
42 |
43 | //具体元素A
44 | public class ElementA : Element
45 | {
46 | public override void Accept(IVistor vistor)
47 | {
48 | //调用访问者vilist
49 | vistor.Visit(this);
50 | }
51 |
52 | public override void Print()
53 | {
54 | Console.WriteLine("我是元素A");
55 | }
56 | }
57 |
58 | //具体元素B
59 | public class ElementB : Element
60 | {
61 | public override void Accept(IVistor vistor)
62 | {
63 | vistor.Visit(this);
64 | }
65 |
66 | public override void Print()
67 | {
68 | Console.WriteLine("我是元素B");
69 | }
70 | }
71 |
72 | //对象结构
73 | public class ObjectStructure
74 | {
75 | private ArrayList element = new ArrayList();
76 |
77 | public ObjectStructure()
78 | {
79 | Random ran = new Random();
80 | for (int i = 0; i < 6; i++)
81 | {
82 | int ranNum = ran.Next(10);
83 | if (ranNum > 5)
84 | {
85 | element.Add(new ElementA());
86 | }
87 | else
88 | {
89 | element.Add(new ElementB());
90 | }
91 | }
92 | }
93 |
94 | public ArrayList Element
95 | {
96 | get { return element; }
97 | }
98 | }
99 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/访问者模式/Program.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :Program
4 | // created by 朱锦润
5 | // created time 2017/07/08 14:22:59
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.访问者模式
10 | {
11 | public class Program : OpenDesign
12 | {
13 | public override void Open()
14 | {
15 | ObjectStructure objectstructure = new ObjectStructure();
16 | foreach (Element e in objectstructure.Element)
17 | {
18 | e.Accept(new ConcreteVistor());
19 | }
20 |
21 | Console.Read();
22 | }
23 | }
24 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/责任链模式/Client.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :Client
4 | // created by 朱锦润
5 | // created time 2017/07/08 13:29:03
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.责任链模式
10 | {
11 | //审批人
12 | public abstract class Approver
13 | {
14 | public Approver(string name)
15 | {
16 | this.Name = name;
17 | }
18 |
19 | public string Name { get; set; }
20 | public Approver NextApprover { get; set; }
21 |
22 | public abstract void ProcessRequest(PurchaseRequest request);
23 | }
24 |
25 | //管理者
26 | public class Manager : Approver
27 | {
28 | public Manager(string name)
29 | : base(name) { }
30 |
31 | public override void ProcessRequest(PurchaseRequest request)
32 | {
33 | if (request.Amount < 10000.0)
34 | {
35 | Console.WriteLine("{0}-{1} approved the request of purshing {2}", this, Name, request.ProductName);
36 | }
37 | else
38 | {
39 | NextApprover.ProcessRequest(request);
40 | }
41 | }
42 | }
43 |
44 | //总经理
45 | public class President : Approver
46 | {
47 | public President(string name)
48 | : base(name) { }
49 |
50 | public override void ProcessRequest(PurchaseRequest request)
51 | {
52 | if (request.Amount < 100000.0)
53 | {
54 | Console.WriteLine("{0}-{1} approved the request of purshing {2}", this, Name, request.ProductName);
55 | }
56 | else
57 | {
58 | Console.WriteLine("Request需要组织一个会议");
59 | }
60 | }
61 | }
62 |
63 | //采购请求
64 | public class PurchaseRequest
65 | {
66 | public PurchaseRequest(double amount, string productName)
67 | {
68 | Amount = amount;
69 | ProductName = productName;
70 | }
71 |
72 | //金额
73 | public double Amount { get; set; }
74 |
75 | //产品名称
76 | public string ProductName { get; set; }
77 | }
78 |
79 | //副总
80 | public class VicePresident : Approver
81 | {
82 | public VicePresident(string name)
83 | : base(name) { }
84 |
85 | public override void ProcessRequest(PurchaseRequest request)
86 | {
87 | if (request.Amount < 25000.0)
88 | {
89 | Console.WriteLine("{0}-{1} approved the request of purshing {2}", this, Name, request.ProductName);
90 | }
91 | else
92 | {
93 | NextApprover.ProcessRequest(request);
94 | }
95 | }
96 | }
97 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/责任链模式/Program.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :Program
4 | // created by 朱锦润
5 | // created time 2017/07/08 13:28:13
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.责任链模式
10 | {
11 | public class Program : OpenDesign
12 | {
13 | public override void Open()
14 | {
15 | PurchaseRequest requestTelphone = new PurchaseRequest(4000.0, "Telphone");
16 | PurchaseRequest requestSoftware = new PurchaseRequest(10000.0, "Visual Studio");
17 | PurchaseRequest requestComputers = new PurchaseRequest(40000.0, "Computers");
18 |
19 | Approver manager = new Manager("LearningHard");
20 | Approver Vp = new VicePresident("Tony");
21 | Approver Pre = new President("BoosTom");
22 |
23 | //设置责任链
24 | manager.NextApprover = Vp;
25 | Vp.NextApprover = Pre;
26 |
27 | //处理请求
28 | manager.ProcessRequest(requestTelphone);
29 | manager.ProcessRequest(requestSoftware);
30 | manager.ProcessRequest(requestComputers);
31 | Console.Read();
32 | }
33 | }
34 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/迭代器模式/Client.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :Client
4 | // created by 朱锦润
5 | // created time 2017/07/07 11:12:11
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.迭代器模式
10 | {
11 | //抽象聚合类
12 | public interface IListCollection
13 | {
14 | Iterator GetIterator();
15 | }
16 |
17 | //抽象迭代器
18 | public interface Iterator
19 | {
20 | Object GetCurrent();
21 |
22 | bool MoveNext();
23 |
24 | void Next();
25 |
26 | void Reset();
27 | }
28 |
29 | //具体迭代器类
30 | public class ConcreteInterator : Iterator
31 | {
32 | private int _index;
33 |
34 | //迭代器要集合对象进行遍历操作，自然就需要引用集合对象
35 | private ConcreteList _list;
36 |
37 | public ConcreteInterator(ConcreteList list)
38 | {
39 | _list = list;
40 | _index = 0;
41 | }
42 |
43 | public object GetCurrent()
44 | {
45 | return _list.GetElement(_index);
46 | }
47 |
48 | public bool MoveNext()
49 | {
50 | if (_index < _list.Length)
51 | {
52 | return true;
53 | }
54 | return false;
55 | }
56 |
57 | public void Next()
58 | {
59 | if (_index < _list.Length)
60 | {
61 | _index++;
62 | }
63 | }
64 |
65 | public void Reset()
66 | {
67 | _index = 0;
68 | }
69 | }
70 |
71 | //具体聚合类
72 | public class ConcreteList : IListCollection
73 | {
74 | private int[] collection;
75 |
76 | public ConcreteList()
77 | {
78 | collection = new int[] { 2, 4, 6, 8 };
79 | }
80 |
81 | public int Length
82 | {
83 | get { return collection.Length; }
84 | }
85 |
86 | public int GetElement(int index)
87 | {
88 | return collection[index];
89 | }
90 |
91 | public Iterator GetIterator()
92 | {
93 | return new ConcreteInterator(this);
94 | }
95 | }
96 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/迭代器模式/Program.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :Program
4 | // created by 朱锦润
5 | // created time 2017/07/07 11:11:44
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.迭代器模式
10 | {
11 | public class Program : OpenDesign
12 | {
13 | public override void Open()
14 | {
15 | Iterator iterator;
16 | IListCollection list = new ConcreteList();
17 | iterator = list.GetIterator();
18 |
19 | while (iterator.MoveNext())
20 | {
21 | int i = (int)iterator.GetCurrent();
22 | Console.WriteLine(i.ToString());
23 | iterator.Next();
24 | }
25 | Console.Read();
26 | }
27 | }
28 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/适配器/CilentClass.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :CilentClass
4 | // created by 朱锦润
5 | // created time 2017/07/03 14:17:22
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.适配器
10 | {
11 | ///
12 | /// 目标角色
13 | ///
14 | public interface IThreeHole
15 | {
16 | void Requset();
17 | }
18 |
19 | ///
20 | /// 适配器类
21 | ///
22 | public class PowerAdpter : TwoHole, IThreeHole
23 | {
24 | public void Requset()
25 | {
26 | this.SpecificRequest();
27 | }
28 | }
29 |
30 | ///
31 | /// 源角色需要适配的类
32 | ///
33 | public class TwoHole
34 | {
35 | public void SpecificRequest()
36 | {
37 | Console.WriteLine("我是两个孔的插头");
38 | }
39 | }
40 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/适配器/CilentObject.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :CilentObject
4 | // created by 朱锦润
5 | // created time 2017/07/03 14:17:31
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.适配器
10 | {
11 | ///
12 | /// 适配器类
13 | ///
14 | public class PowerAdapter : ThreeHole2
15 | {
16 | //引用实例
17 | public TwoHole2 twh = new TwoHole2();
18 |
19 | public override void Request()
20 | {
21 | twh.SpecificRequest();
22 | }
23 | }
24 |
25 | ///
26 | /// 三个孔插头，目标角色
27 | ///
28 | public class ThreeHole2
29 | {
30 | //客户端需要的方法
31 | public virtual void Request()
32 | {
33 | //可以把一般实现放在这里
34 | Console.WriteLine("我是三个孔插头");
35 | }
36 | }
37 |
38 | ///
39 | /// 两个孔插头，源角色
40 | ///
41 | public class TwoHole2
42 | {
43 | public void SpecificRequest()
44 | {
45 | Console.WriteLine("我是两个孔插头");
46 | }
47 | }
48 | }
--------------------------------------------------------------------------------
/HE23DesignPatterns/适配器/Program.cs:
--------------------------------------------------------------------------------
1 | //--------------------------------------------
2 | // Copyright (C) 武汉一世计科软件有限公司
3 | // filename :Program
4 | // created by 朱锦润
5 | // created time 2017/07/03 14:17:02
6 | //--------------------------------------------
7 | using System;
8 |
9 | namespace DesignMethod.适配器
10 | {
11 | public class Program : OpenDesign
12 | {
13 | public override void Open()
14 | {
15 | #region OpenClass
16 |
17 | IThreeHole threehole = new PowerAdpter();
18 | threehole.Requset();
19 | Console.ReadLine();
20 |
21 | #endregion OpenClass
22 |
23 | #region OpenObject
24 |
25 | ThreeHole2 three = new PowerAdapter();
26 | three.Request();
27 | Console.ReadLine();
28 |
29 | #endregion OpenObject
30 | }
31 | }
32 | }
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # AlgorithmAndDesignPartten
2 | 基于C#语言的查找、排序算法以及23设计模式的汇总
3 |
--------------------------------------------------------------------------------
/基于C#的23种设计模式.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Run2948/AlgorithmAndDesignPartten/ee365382368c6a97be3c45c13745d17f6095f586/基于C#的23种设计模式.pdf
--------------------------------------------------------------------------------
/数据结构与算法：C#语言描述(中文).pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Run2948/AlgorithmAndDesignPartten/ee365382368c6a97be3c45c13745d17f6095f586/数据结构与算法：C#语言描述(中文).pdf
--------------------------------------------------------------------------------