.NET与设计模式[按需印刷]

.1.7.2 不能提高开发速度或者形象开发速度 10
1.7.3 不是万能的 11
1.8 设计模式的非软件示例 11
1.9 小结 13
第2章 uml与设计模式 14
2.1 gof设计模式中的图示法 14
2.2 uml表示法 14
2.2.1 uml类图 14
2.2.2 uml对象图 18
2.2.3 uml序列图 19
2.3 《设计模式》中图示法与uml的区别 19
2.4 设计模式的逻辑模型和实现模型 20
2.5 使用case工具 22
2.6 小结 22
第3章 面向对象软件设计的目标、原则和难点 23
3.1 软件设计的目标 23
3.2 “开–闭”原则 24
3.3 实现“开–闭”原则 24
3.3.1 面向接口编程 24
3.3.2 封装变化 24
3.3.3 采用组合替代继承 25
3.4 面向对象软件设计的难点 26
3.5 设计模式解决的问题 27
3.5.1 通过显示指定类创建对象 27
3.5.2 紧耦合 27
3.5.3 通过生成子类扩展功能 28
3.5.4 对对象表示或实现的依赖 28
3.5.5 不能方便地修改类 28
3.5.6 对算法的依赖 29
3.5.7 对软硬件环境的依赖 29
3.6 小结 29
第4章 小题大做：人戴帽子——面向对象设计与设计模式 30
4.1 人戴帽子的需求 30
4.2 简单方案 30
4.3 能否适应帽子种类的变化 32
4.4 人的行为可变性 32
4.5 谁给人戴帽子——在何处实例化对象 37
4.6 不戴帽子就不能游泳吗——解耦 38
4.7 设计模型的适应性 40
4.8 人戴帽子：并非小题大做——面向对象设计与设计模式 41
4.8.1 模型回顾 41
4.8.2 游戏建模 42
4.8.3 工作流中的角色与职责 42
4.9 小结 43
第5章 在.net平台下使用设计模式 45
5.1 .net概述 45
5.1.1 .net的组成 45
5.1.2 .net框架内核 46
5.1.3 clr 46
5.1.4 类库 46
5.2 反射技术 47
5.2.1 .net可执行应用程序结构 47
5.2.2 反射技术示例 48
5.2.3 在设计模式实现中使用反射技术 50
5.3 委托技术 50
5.3.1 概述 50
5.3.2 示例 51
5.3.3 委托技术与gof设计模式中委托的关系 52
5.3.4 委托技术与设计模式实现 53
5.4 数据绑定 53
5.4.1 作用 53
5.4.2 windows窗体中的数据绑定 55
5.4.3 asp.net中的数据绑定 55
5.4.4 数据绑定与设计模式 56
5.5 对象的序列化 56
5.6 web应用中的技术 57
5.6.1 web窗体的状态管理 57
5.6.2 cache 60
5.7 接口和类 61
5.7.1 icloneable 61
5.7.2 ienumerable和ienumerator 61
5.7.3 menucommand类与imenucommandservice接口 61
5.7.4 collectionbase类 61
5.7.5 idataadapter 61
5.8 小结 61
第2篇 设计模式的实现与使用
第6章 简单工厂 65
6.1 引言 65
6.2 概述 67
6.2.1 意图 67
6.2.2 使用场合 67
6.2.3 效果 67
6.3 .net实现 68
6.3.1 实现要点 68
6.3.2 结构 68
6.3.3 代码框架 69
6.4 获得数据库连接对象 70
6.5 获得配置文件访问对象 71
6.5.1 问题 71
6.5.2 结构和代码 71
6.5.3 效果 73
6.6 获得数据流访问对象 74
6.6.1 问题 74
6.6.2 代码 74
6.6.3 访问web站点 74
6.7 简单工厂的综合应用 75
6.8 相关模式 75
第7章 工厂方法模式 76
7.1 引言 76
7.2 概述 77
7.2.1 意图 77
7.2.2 使用场合 77
7.2.3 结构 77
7.2.4 效果 78
7.3 鸟生蛋的模化 78
7.4 .net中的工厂方法——获得迭代器 78
7.5 获得多媒体播放对象 79
7.6 相关模式 80
第8章 抽象工厂 81
8.1 引言 81
8.2 概述 82
8.2.1 意图 82
8.2.2 使用场合 82
8.2.3 结构 82
8.2.4 实现示例 83
8.2.5 效果 84
8.3 数据库访问类的优化 85
8.4 抽象工厂在组态软件中的应用 87
8.5 相关模式 89
第9章 .net的反射工厂 91
9.1 引言 91
9.2 采用反射技术简化工厂类 92
9.3 反射工厂 93
9.3.1 对简单工厂的改进 93
9.3.2 反射与工厂方法 94
9.3.3 反射与抽象工厂 94
9.4 反射工厂的应用实例 95
9.5 ndoc中的文档生成器工厂 95
9.5.1 问题 95
9.5.2 分析 95
9.5.3 实现 96
9.5.4 效果 97
9.6 反射工厂的使用效果 97
9.7 小结 97
第10章 生成器 98
10.1 引言 98
10.2 概述 100
10.2.1 意图 100
10.2.2 使用场合 100
10.2.3 结构 100
10.2.4 实现示例 101
10.2.5 效果 103
10.3 生成器模式与抽象工厂的区别 103
10.4 实现web资源管理软件 105
10.5 支持windows应用和web应用的界面生成器 110
10.5.1 数据库编辑界面的自动生成 110
10.5.2 同时支持web应用 112
10.5.3 导航器和生成器接口 112
10.5.4 windows界面的生成器 114
10.5.5 web界面的生成器 116
10.6 生成器与生成器模式 118
10.7 相关模式 118
第11章 原型模式 119
11.1 引言 119
11.2 概述 120
11.2.1 意图 120
11.2.2 使用场合 120
11.2.3 结构 120
11.2.4 效果 121
11.3 .net实现 121
11.3.1 icloneable接口 121
11.3.2 实现结构 121
11.3.3 深复制与浅复制 122
11.4 复制商品房销售系统中楼盘 122
11.4.1 结构 122
11.4.2 强制类型集合 123
11.4.3 实现业务类 126
11.4.4 使用 127
11.4.5 效果 128
11.5 .net中的原型模式 128
11.6 创建自定义图元 128
11.6.1 问题 128
11.6.2 解决方案 129
11.6.3 实现icloneable接口 129
11.6.4 构造工厂 130
11.6.5 状态管理 131
11.6.6 实现橡皮筋 131
11.6.7 效果 133
11.7 总结 133
11.8 相关模式 133
第12章 专题——克隆图 134
12.1 图的结构 134
12.2 克隆图的难点 136
12.3 实现 138
12.4 实例——矢量图编辑软件中的拷贝/粘贴 139
12.5 小结 140
第13章 单件模式 141
13.1 概述 141
13.1.1 意图 141
13.1.2 使用场合 141
13.1.3 结构 141
13.1.4 效果 141
13.2 .net实现 142
13.3 单件计数器 142
13.4 单件窗体 143
13.5 全局变量与单件 144
13.6 单件与实用类中的静态方法 145
13.7 总结 145
13.8 相关模式 145
第14章 与对象创建相关的其他问题 146
14.1 构造函数 146
14.1.1 公共构造函数 146
14.1.2 私有构造函数 146
14.1.3 保护构造函数 147
14.1.4 静态构造函数 147
14.2 仅通过工厂获得实例 148
14.3 采用内部类封装实现 149
14.4 注册工厂 150
14.5 小结 151
第15章 适配器模式 152
15.1 概述 152
15.1.1 意图 152
15.1.2 结构 152
15.1.3 使用场合 154
15.2 多媒体播放对象 154
15.3 应用系统间的接口 156
15.4 通信接口 159
15.6 .net中的适配器——dataadapter 160
15.7 相关模式 161
第16章 桥接模式 162
16.1 概述 162
16.1.1 意图 162
16.1.2 使用场合 162
16.1.3 结构 162
16.1.4 效果 164
16.2 数据库表编辑窗体——.net实现 164
16.3 多种数据源与多种数据显示方式的组合 168
16.4 生成报表 170
16.5 相关模式 172
第17章 外观模式 173
17.1 概述 173
17.1.1 意图 173
17.1.2 使用场合 173
17.1.3 结构 173
17.1.4 效果 174
17.2 数据库访问外观模式 175
17.3 分层结构与外观模式 176
17.4 封装子系统 177
17.5 子系统隔离 178
17.6 系统演化 178
17.7 相关模式 178
第18章 适配器模式、桥接模式与外观模式 180
18.1 适配器模式与桥接模式的区别和联系 180
18.2 适配器模式与桥接模式的联合 181
18.3 适配器模式与外观模式的关系 182
18.4 小结 183
第19章 装饰模式 184
19.1 引言 184
19.2 概述 186
19.2.1 意图 186
19.2.2 结构 186
19.2.3 适用性 187
19.2.4 实现时的注意事项 187
19.2.5 效果 188
19.3 网页组件装饰器 188
19.4 bufferedstream——.net中的装饰模式实例 191
19.5 装饰≠装饰模式——采用collectionbase实现强制类型集合 193
19.6 操作记录 194
19.6.1 问题 194
19.6.2 结构 195
19.6.3 代码实现 195
19.6.4 结果 197
19.7 改变外观还是改变内核 197
19.8 相关模式 198
第20章 代理模式 199
20.1 引言 199
20.2 概述 200
20.2.1 意图 200
20.2.2 使用场合 200
20.2.3 结构 201
20.2.4 结果 201
20.3 测试中的“占位”对象 202
20.4 .net中的代理模式——xmlweb service 205
20.5 .net中的代理模式——realproxy 206
20.6 去掉冗余的权限 208
20.6.1 问题 208
20.6.2 结构 209
20.6.3 代码实现 209
20.6.4 结果 210
20.7 相关模式 210
第21章 组合模式 211
21.1 概述 211
21.1.1 意图 211
21.1.2 使用场合 211
21.1.3 结构 211
21.1.4 效果 212
21.2 .net控件——组合模式在.net中的实例 212
21.3 .net实现 214
21.3.1 组合模式的不同实现方式 214
21.3.2 强制类型集合或非强制类型集合 215
21.3.3 实现递归遍历 215
21.4 复杂报表的指标树 215
21.4.1 问题 215
21.4.2 结构 216
21.4.3 代码 217
21.5 数据采集系统的显示组件 219
21.5.1 问题 219
21.5.2 结构 219
21.5.3 效果 221
21.6 油品库存模型 221
21.6.1 问题 221
21.6.2 结构 221
21.6.3 效果 222
21.7 mrp中的bom 222
21.7.1 问题 222
21.7.2 结构 222
21.7.3 效果 222
21.8 组合模式、装饰模式和代理模式 222
21.9 与其他模式的关系 224
第22章 享元模式 225
22.1 概述 225
22.1.1 意图 225
22.1.2 使用场合 225
22.1.3 结构 225
22.1.4 效果 226
22.2 html中的图像——享元模式实例 226
22.3 围棋 227
22.4 相关模式 232
第23章 享元模式与共享对象 233
23.1 什么是共享对象 233
23.2 共享对象与注册工厂 233
23.3 共享商品房类型 233
23.4 共享编辑窗体 235
23.5 小结 241
第24章 职责链模式 242
24.1 引言 242
24.2 概述 242
24.2.1 意图 242
24.2.2 使用场合 242
24.2.3 结构 243
24.2.4 职责链模式构成与执行效率 243
24.2.5 结果 244
24.3 文法分析器——四则运算式解析 244
24.3.1 问题 244
24.3.2 方案 244
24.3.3 结果 250
24.4 计算后则表达式 250
24.4.1 问题 250
24.4.2 方案 250
24.4.3 结果 253
24.5 用于计算的职责链示例——计算所得税 253
24.5.1 问题 253
24.5.2 方案 254
24.6 实现异常保护 257
24.6.1 问题 257
24.6.2 解决方案 258
24.6.3 结果 260
24.7 相关模式 260
第25章 命令模式 261
25.1 引言 261
25.2 概述 261
25.2.1 意图 261
25.2.2 使用场合 261
25.2.3 结构 261
25.2.4 理解结构 262
25.2.5 效果 262
25.3 采用命令模式支持“取消”与“重做”功能 263
25.4 实现“取消”与“重做”功能 264
25.5 限制角色行为 265
25.6 iolecommandtarget接口与命令模式 269
25.6.1 iolecommandtarget 269
25.6.2 iolecommandtarget的调用 270
25.6.3 mshtml与iolecommandtarget接口 270
25.6.4 使用示例 273
25.6.5 结果 277
25.7 相关模式 277
第26章 解释器模式 278
26.1 引言 278
26.2 语法规则、分析器和解释器 278
26.3 概述 279
26.3.1 意图 279
26.3.2 应用场合 279
26.3.3 结构 279
26.3.4 效果 280
26.4 简单的机器人语言 280
26.5 创建机器人语言的解释器 280
26.6 命令分析器与解释器 285
26.7 相关模式 287
第27章 迭代器模式 288
27.1 概述 288
27.1.1 意图 288
27.1.2 使用场合 288
27.1.3 结构 288
27.1.4 效果 289
27.2 .net中的迭代器模式 289
27.3 强制类型集合与迭代器模式 290
27.4 遍历web缓存 293
27.5 相关模式 293
第28章 备忘录模式 294
28.1 引言 294
28.2 概述 294
28.2.1 意图 294
28.2.2 结构 294
28.2.3 使用场合 295
28.2.4 效果 295
28.3 备忘录模式的基本框架 295
28.4 实现要点分析 298
28.5 实现宽接口和窄接口 300
28.6 相关模式 302
第29章 状态模式 303
29.1 概述 303
29.1.1 意图 303
29.1.2 使用场合 303
29.1.3 结构 303
29.1.4 效果 304
29.2 状态和状态模式的进一步讨论 304
29.3 冷暖空调的控制器 306
29.4 图形编辑器中的状态模式 308
29.5 实现用户权限的多态性 311
29.6 工作流与状态模式 312
29.7 相关模式 313
第30章 观察者模式 314
30.1 概述 314
30.1.1 意图 314
30.1.2 使用场合 315
30.1.3 结构 315
30.1.4 效果 316
30.2 采用委托和事件机制实现观察者模式 316
30.2.1 c#实现方法 317
30.2.2 采用withevents——vb.net的实现方法 318
30.2.3 与传统实现方法比较 319
30.3 web查询结构 320
30.4 e-mail和短消息通知 323
30.5 事件连锁 331
30.6 相关模式 332
第31章 中介者模式 333
31.1 概述 333
31.1.1 意图 333
31.1.2 使用场合 333
31.1.3 结构 333
31.1.4 效果 334
31.2 采用委托技术简化中介者模式的结构 334
31.3 .net中的中介者模式——窗体与窗体控件 335
31.4 界面与业务类交互的中介者 337
31.4.1 编辑界面接口 337
31.4.2 数据访问接口 338
31.4.3 中介者 338
31.4.4 实现 339
31.5 工作流与中介者模式 341
31.5.1 工作流简介 341
31.5.2 工作流与中介者模式 342
31.6 相关模式 344
第32章 策略模式 345
32.1 引言 345
32.2 模式概述 345
32.2.1 意图 345
32.2.2 使用场合 345
32.2.3 结构 346
32.2.4 效果 346
32.3 加密和解密 347
32.4 计算库存下限 350
32.4.1 问题 350
32.4.2 结构 351
32.4.3 实现 351
32.5 采用委托技术的策略模式 354
32.6 相关模式 355
第33章 模板方法模式 356
33.1 引言 356
33.2 模式概述 356
33.2.1 意图 356
33.2.2 使用场合 357
33.2.3 结构 357
33.2.4 效果 358
33.3 sql生成器——.net实现 358
33.4 通信程序中的模板方法 360
33.5 绘制图形中的模板方法 361
33.6 采用委托实现模板方法 364
33.7 相关模式 365
第34章 访问者模式 366
34.1 概述 367
34.1.1 意图 367
34.1.2 使用场合 368
34.1.3 结构 368
34.1.4 效果 369
34.2 .net实现 370
34.3 访问者模式与非强制类型集合 372
34.4 相关模式 378
第35章 访问模式使用专题：访问业务域模型 379
35.1 信息系统的组成 379
35.2 业务域模型 379
35.3 在子系统中使用业务域模型 380
35.4 采用访问者模式为业务对象增加操作 381
35.5 小结 382
第36章 委托技术与行为型设计模式 383
36.1 封装变化与面向接口编程 383
36.2 委托技术的使用场合 384
36.3 采用委托技术实现的设计模式 384
36.3.1 模板方法的结构 384
36.3.2 策略模式 386
36.3.3 中介者模式 387
36.3.4 观察者模式 388
36.4 用组合替代继承 389
36.5 设计模式的发展 389
36.6 小结 390
第3篇 开源项目中的设计模式
第37章 nunit中的设计模式 393
37.1 nunit结构组成与设计模式 393
37.2 简单工厂 394
37.2.1 testcasebuilder 394
37.2.2 testsuitebuilder 396
37.3 组合模式 398
37.3.1 测试结果 399
37.4 模板方法——执行测试用例 400
37.5 测试用例的动态绑定 403
37.6 访问者模式 404
37.7 装饰器模式 407
37.7.1 封装textwriter 407
37.7.2 作为treeview节点的test 408
37.8 适配器模式 410
37.9 观察者模式 411
37.10 小结 414
第38章 dotnetnuke中的设计模式 415
38.1 dotnetnuke简介 415
38.2 dotnetnuke与设计模式 415
38.3 采用反射技术的工厂方法 416
38.3.1 数据提供对象 416
38.3.2 创建业务逻辑对象 417
38.3.3 创建日志记录器 421
38.4 装饰器模式——为模块提供容器 422
38.5 web应用中的命令模式——编辑菜单 424
38.6 组合模式——栏目组成 426
38.7 享元模式 428
38.8 桥接模式——日志记录 430
38.9 策略模式——支持多种类型的html编辑器 432
38.10 观察者模式——实现模块间通信 436
38.11 适配器模式——实现版本兼容 438
38.12 小结 439
第39章 gentle中的设计模式 440
39.1 模式一览 440
39.2 采用反射的工厂方法 440
39.3 抽象工厂——针对不同数据库的访问提供者 441
39.4 组合模式——sql语句描述 445
39.5 迭代器模式——自定义cache的访问 448
39.6 外观模式 449
39.7 小结 450
第40章 log4net中的设计模式 451
40.1 log4net介绍 451
40.2 模式一览 451
40.3 工厂方法 451
40.3.1 iloggerfactory 451
40.3.2 ipluginfactory 453
40.4 模板方法 454
40.5 桥接 456
40.6 职责链模式 457
40.7 适配器模式 459
40.8 原型模式 461
40.9 迭代器模式 462
40.10 小结 463
第4篇 模式与交流
第41章 在组织中使用设计模式 467
41.1 需求及其分析 467
41.2 设计模式在组织中的作用 467
41.3 将设计模式引入组织遇到的困难 468
41.4 将设计模式引入组织的方法 469
41.4.1 设定开发人员的知识体系 469
41.4.2 建立合理的培训体制 469
41.4.3 重视项目的重构 469
41.4.4 逐渐将设计模式引入开发流程 470
第42章 发掘模式 471
42.1 为什么要发掘模式 471
42.1.1 提高抽象能力 471
42.1.2 提高书面表达能力 471
42.1.3 有助于团队意识的培养 472
42.2 发明还是发现 472
42.3 模式的范围 473
42.3.1 方言 473
42.3.2 模式语言 473
42.4 如何发现模式 473
42.4.1 前提 473
42.4.2 确定范围 473
42.4.3 明确问题及其所处的上下文 474
42.4.4 确定forces 474
42.4.5 描述解决方案 475
42.4.6 效果 475
42.4.7 模式名称 476
42.4.8 模式的其他部分 476
42.5 模式的shepherd过程 476
42.6 模式的workshop 476
第43章 小组学习的范例——plop的workshop 477
43.1 传统会议的不足 477
43.2 plop workshop的组织形式 477
43.3 plop workshop的优点 478
43.4 组织自己的workshop 478
第44章 模式的发展 479
44.1 模式的书写方式和形成过程基本成熟 479
44.2 模式覆盖的范围越来越广 479
44.3 越来越多的领域产生模式语言 480
44.4 模式发展的良性循环 480
附录a 设计模式与设计模式组合速查 481
参考文献 492
后记 495

.　　 （3）充分了解所使用的开发平台。
　　 总的来说，设计模式是针对面向对象的软件设计的，因此在理论上适合任何面向对象的语言。但随着技术的发展和编程环境的改善，设计模式的实现方式会有很大的差别。在某些平台下，某些设计模式是自然实现的，某些模式已经被平台所实现，某些模式存在的上下文已经消失。
　　 这里的平台不仅指编程语言，还包括平台引入的技术。.NET平台引进了反射、委托，以及类属性等新技术，这些技术的使用使设计模式的实现方式有了很大的改变。例如，工厂方法通过采用反射技术，可以将其中的子类去掉。这实际上已经是一个.NET下的新模式，或者说是.NET的“方言”。
　　 （4）编程，编程，还是编程。
　　 软件开发是一项实践工作，最直接的方法就是编程。没有定式很熟却从来不下棋的围棋高手，也没有不会编程就成为架构设计师的先例。对设计模式的掌握是水到渠成的事情，你可能是“顿悟”，也可能是“渐悟”，但前提是必须有相当的实践积累。当然，并不是不需要看书学习，但实践仍然是必须首先要重视的。
　　 笔者认为编程如同写文章，提高需要有一个过程。在多多编程的同时，需要有一定的技巧。如果希望水平有较大提高，则需要对自己编写的代码不断重构。力求最优是个很好的习惯，当然前提是项目进度允许。即使项目时间紧张，也需要进行适当的总结。隔一段时间检查一下以前的工作，会发现自己是否已经有了提高。
　　 （5）避免设计过度。
　　 设计模式解决的是设计不足的问题，但同时也要避免设计过度。一定要牢记简洁原则（Keep It Simple，Stupid，KISS），要知道，设计模式是为了使设计简单，而不是更复杂。如果引入设计模式使设计变得复杂，只能说我们把简单的问题复杂化了，问题本身不需要设计模式。
　　 这里需要把握的是需求变化的程度，一定要区分需求的稳定篇和可变篇。一个软件必然有稳定的篇，这个篇就是核心业务逻辑。如果核心业务逻辑发生变化，软件就没有存在的必要，这个篇的逻辑是我们需要固化的。对于可变的篇，需要判断可能发生变化的程度来确定设计策略和设计风险。要知道，设计过度与设计不足同样对项目有害。
　　 （6）合理看待设计模式的实现实例。
　　 现在，从各种途径可以发现各种设计模式的实现实例。需要说明的是，其中很多实例所说明的仅仅是设计模式的解决方案的实现，并没有分析模式使用的上下文。实际上，这也是最困难的篇——从而导致实例中的设计模式使用从实践的角度看，往往是过度设计，也就是有小题大做的嫌疑。实际上，本书中的有些实例也是这样。这是因为描述一个复杂应用的场合需要大量的篇幅，可能使读者花费很多的时间和精力在与自己不相干的业务描述上，但如果不如此处理，则无法使读者理解使用设计模式的必要性和难点，这样就造成了两难选择。很多讲解模式的书籍和文章只好将问题简化，可是这样的处理，虽然读者易于理解模式的实现方式，却经常忽略了分析问题的篇，或者是认为这些实例是设计过度。笔者在编写本书之前，也认为很多关于模式的文章会误导读者，因为很多场景根本没有必要使用某种设计模式，但实际编写起来，则发现几方面都照顾到确实很困难。为此需要读者在学习模式时合理看待这些实例，而不要生搬硬套。
　　 讲解设计模式的难度
　　 关于模式和设计模式的书已经有很多了，在国外很多书店中有关于模式的专架。然而，想通过一本书将设计模式讲解得完全透彻是一件很困难的事，原因如下。
　　 （1）笔者所处领域的局限性。
　　 前面已经提到了，设计模式针对的不仅仅是解决方案，更重要的是问题出现的场景。正因为如此，正确分析设计模式的应用场景是非常重要的。软件开发是需求驱动的，需求来源于解决某一方面的问题。如果读者对需求的背景不了解，就很难理解相应的软件结构和采用设计模式的必要性。可是“隔行如隔山”，向没有专业背景的读者介绍另一个领域的需求是一件很困难的事。《设计模式精解》（Design Patterns Explained）是一本不错的关于设计模式的书，但其中的实例只是针对CAD/CAM软件的。如果读者不是很了解其中的需求背景，则无法真正理解其中谈到的设计模式。
　　 （2）笔者经验的局限性。
　　 GOF的设计模式有23种，这是从无数实际项目中抽取出来的。但在实际项目中没有哪个项目中可以用到如此之多的模式，开发人员很少有可能在实际项目中都应用过这23种模式。某些模式可能一生也用不到（因为没有合适的使用场景），因此在介绍时就会有所偏重。
　　 （3）示例代码的繁简程度。
　　 设计模式在一定的设计场合下才能显示其优越性，如果把这种优越性表现出来，需要相应的代码，而在一本书中完全展现代码往往是不可能的。另一方面，如果对代码做过多的裁剪，则又不能展现完整的设计场合，从而会使读者忽略了其中的精华。GOF的《设计模式》一书之所以受欢迎，笔者认为其中的原因之一就是其繁简得当。记得最初学习工厂方法时，怎么也不明白为什么这种方法是必要的。主要原因就是当时看到的示例代码过于简单，以至于采用了工厂方法反而使设计看起来变得不必要的复杂，所以除非对实质把握得非常到位，否则采用过多的伪码反而会难以理解。
　　 （4）现实的案例。
　　 如果设计模式仅仅限于概念层的讨论，是不能满足解决实际项目问题的需要的。这时需要有真实的案例分析，然而做到这一点绝非易事，因为现实的案例有其特定的业务上下文。如果让读者理解为什么这个方案要采取这个模式，就需要对业务环境有比较详细的描述。而这些业务环境对于读者而言，除了理解方案，没有其他用处，除非某些读者的工作领域与作者相同。
　　 本书的结构
　　 本书试图使读者对设计模式有一定的了解并对实际项目有所帮助，全书分为4篇。
　　 第1篇是面向对象设计的一些基本原则和由.NET引入的新概念。
　　 设计模式的引入针对面向对象设计中的难点，因此，有必要了解这些难点之所以成为难点的原因。通过这一篇的示例，我们会发现设计模式的使用是自然的，也是必然的。
　　 第2篇逐一介绍设计模式，本书以GOF的23种设计模式为主线介绍，在介绍每一种设计模式时大致采用如下的结构。
　　 （1）从一个容易理解的需求背景入手，说明为什么要引入某一个设计模式。
　　 （2）介绍设计模式的动机、使用环境、结构、收益与代价。
　　 （3）介绍如何在.NET环境中实现这个模式，并给出代码框架。为了考虑到代码的完整性和篇幅之间的关系，书中仅列出代码片段。
　　 （4）介绍应用实例，这些实例来源于实际项目，可以从不同的角度说明应用设计模式时应注意的问题。这些实例点到为止，主要说明在什么样的业务环境下可以考虑用什么样的设计模式。
　　 （5）介绍相关模式并进行总结。
　　 这个部分采用两种不同的代码示例，当我们讨论模式的实现时，将采用比较简单的例子，以说明如何实现模式。这些例子只是为了说明实现的方法，但并不说明模式的上下文和作用力。还有一种是从实际项目中抽取的，并且经过适当裁剪的实例。这些例子着重讨论使用模式的环境和效果，以及在选择模式时所做的妥协。笔者希望通过这两类示例能使读者通过有限的篇幅对模式有比较全面的了解。
　　 第3篇介绍设计模式在几个开放源码中的应用。
　　 设计模式是为软件设计服务的，单纯对单个模式的理解并不代表已经掌握了设计模式。在真实世界的项目中会面临多种问题和选择，在真正项目中学习如何使用设计模式的，会起到事半功倍的效果。
　　 感谢开放源代码项目为我们提供了现成的示例，本书选择如下几种应用广泛的.NET开源项目。
　　 · DotNetNuke：开放源码的Portal。
　　 · NUnit：.NET的单元测试框架。
　　 · Ndoc：文档生成工具。
　　 · Gentle：对象持续化框架。
　　 这些项目的源代码可以免费获得，并且广泛地应用在.NET开发人员的日常工作中。这样可以不用过多地介绍应用背景，即可使读者专注于设计模式的讨论。通过对这些项目中设计模式的分析，希望能使读者从整个项目的角度把握设计模式的应用。
　　 第4篇介绍模式的更一般的概念。模式世界中不仅包括设计模式（尽管它是最流行的），还有分析模式和体系结构模式等。这一篇介绍了模式的历史、如何发现和书写模式，以及模式社会的交流场所PLoP（Pattern Language of Program，程序模式语言大会）等。本篇主要结合笔者的经历，希望对模式研究有兴趣的读者有所帮助，也希望能形成我们自己的模式社区和团体。
　　 致谢
　　 感谢与笔者工作过的同事和客户的支持与帮助，也感谢笔者的家人在各方面的支持。
　　 感谢笔者在模式学习和实践过程中曾给予过帮助的同行，特别感谢笔者PLoP 2002和PLoP 2003论文的Shepherd——Ed Fernandez和Jutta Eckstein，以及参与讨论的工作组成员。
　　 感谢电子工业出版社对笔者的信任和支持，感谢本书策划编辑朱沭红、责任编辑孙学瑛为本书所做的工作。
　　 请与我联系
　　 限于笔者的水平，书中错误和不妥之处在所难免，也希望读者多多批评指正。笔者的E-mail地址是zl@hzchina.net，读者也可以访问http://www.hzchina.net/patterns。