.NET2.0模式开发实践

　　本书阐述了应用于.NET 2.0框架的设计模式，重点以C#语言来演示应用各种模式。书中的主要内容包括面向对象编程的实质、模块化和异常、测试驱动开发、基本设计模式、应用于架构策略的设计模式、序列化和持久化等，同时针对测试、模式和重构，阐述了相关联的面向对象编程。　本书适合高等学校计算机相关专业师生，以及从事.NET程序设计的程序员阅读。

　　Christian Gross是一位经验丰富、多才多艺的软件顾问，客户包括微软、戴姆勒－奔驰等大型公司。他精通各种微软客户端/服务器技术。除本书外，他还撰写了畅销书Ajax Patterns and Best Practices，并与人合作撰写了许多ASP、SQL Server、Windows编程方面的技术图书。

第1章 面向对象编程的实质                    1
1.1 理解类型                      1
1.2 模块化与可重用代码                      3
1.3 利用作用域控制访问                      5
1.4 理解继承                      7
1.4. 1class与struct在继承上的区别                      8
1.4.2 简单的继承                      11
1.4.3 利用虚函数继承                      12
1.5 软件工程中的继承                      13
1.6 编写泛型代码                      15
1.6.1 泛型的实例                      15
1.6.2 约束                      16
1.6.3 一些思考                      18
1.7 组合                      18
1.8 异步代码                      19
1.9 最后的思考                      21
第2章 日志、错误与测试驱动开发                      22
2.1 日志管理                      22
2.1.1 简单的log4net例子                      22
2.1.2 利用ILog接口生成消息                      24
2.1.3 管理配置文件                      25
2.1.4 建立一个现实的配置                      27
2.1.5 实现ToString                    34
2.2 实现异常处理                      35
2.2.1 错误与异常分类                      35
2.2.2 实现错误策略                      37
2.2.3 实现异常策略                      44
2.3 使用NUnit来做测试驱动开发                      48
2.3.1 理解测试驱动开发                      49
2.3.2 在应用程序中使用NUnit                    50
2.3.3 运行NUnit测试                      51
2.3.4更多详细的NUnit测试                      51
2.4 最后的思考                      54
第3章 定义根基                      56
3.1 定义应用程序的基础                      56
3.1.1 定义意图                      56
3.1.2 测试驱动开发                      58
3.2 实现Bridge模式                      62
3.2.1 使用接口时留有选择余地                      63
3.2.2 过犹不及                      64
3.2.3 关于.NET1.x                    65
3.3 Bridge模式实现变种                      66
3.3.1 实现应用程序逻辑                      66
3.3.2 控制器接口                      69
3.3.3 实现默认的基类                      70
3.3.4 接口和类的设计决策                      73
3.4 使用Factory模式实例化类型                      77
3.4.1 需要帮助类型                      77
3.4.2 实现插件架构                      78
3.4.3 根据计划创建对象                      80
3.4.4 克隆对象                      80
3.5最后的思考                      81
第4章 应用程序的架构                      82
4.1 使应用程序正常运行                      82
4.1.1 可扩展性和可维护性                      83
4.1.2 使用黑盒                      83
4.2 PipesandFilters模式                      85
4.2.1 例子：从Amazon.com购买电视机                      85
4.2.2 电视机选择系统的架构                      86
4.2.3 电视机选择系统的实现                      87
4.2.4 关于PipesandFilters模式的几点思考                      95
4.3 Client-Dispatcher-Server模式                      96
4.3.1 定义Client-Dispatcher-Server模式的架构                      97
4.3.2 静态分配器架构                      98
4.3.3 动态分配器架构                      99
4.3.4 架构Client-Dispatcher-Server模式                      101
4.3.5 实现程序集目录解析器                      103
4.3.6 实现Web服务解析器                      109
4.4 Micro-Kernel模式                      111
4.4.1 微内核的架构                      111
4.4.2 隐藏微内核的细节                      112
4.4.3 设计微内核                      113
4.4.4 微内核实现细节                      114
4.4.5 构建简单的银行应用程序                      114
4.4.6 关于Micro-Kernel模式的思考                      120
4.5 最后的思考                      120
第5章 实现成组的组件                      121
5.1 两个传统的面向对象错误                      121
5.1.1 属性和烤箱温度控制                      122
5.1.2 继承和基类的脆弱性问题                      124
5.2 示例应用：翻译程序                      128
5.2.1 快速编写一个简陋的应用程序                      128
5.2.2 重构代码                      130
5.2.3 重构并且实现Bridge和Factory                      130
5.2.4 实现Mediator模式                      132
5.2.5 实现Template模式                      137
5.2.6 实现Adapter模式                      142
5.2.7 关于翻译程序的最后思考                      146
5.3 为应用程序添加多语言支持                      146
5.3.1 想想看：Decorator还是Composite                      146
5.3.2 实现ChainofResponsibility模式                      147
5.3.3 实现Command模式                      151
5.3.4 实现Composite模式                      154
5.3.5 实现Decorator模式                      156
5.3.6 实现State模式                      159
5.3.7 实现Strategy模式                      164
5.3.8 实现翻译语言的动态选择                      165
5.4 最后的思考                      166
第6章 编写算法                      168
6.1 不做修改的功能模仿                      168
6.1.1 实现Proxy模式                      169
6.1.2 使用仿函数增强类型                      170
6.1.3 为集合创建泛型仿函数架构                      178
6.2 构建电影票应用程序                      181
6.2.1 从基础开始                      181
6.2.2 计算票的销售额                      182
6.2.3 读取销售额数据                      184
6.2.4 使用null的问题                      186
6.2.5 更为简单的买票方法：使用Facade模式                      189
6.3 使用多态管理扩展                      193
6.3.1 实现StaticExtension模式                      193
6.3.2 实现DynamicExtension模式                      198
6.3.3 扩展、类型转换以及它们的意义                      202
6.4 使用Iterator模式遍历数据                      203
6.4.1 使用C#2.0实现Iterator模式                      203
6.4.2 在迭代器中使用仿函数                      204
6.5 最后的思考                      205
第7章 高效代码                      206
7.1 不可变类是高效的类                      206
7.1.1 为什么不可变类具有一致性                      206
7.1.2 为什么不可变类是可伸缩的                      213
7.1.3 一些使用不可变类的经验                      216
7.2 在Flyweight模式中使用不可变类                      217
7.2.1 Flyweight模式的例子                      217
7.2.2 通用的Flyweight架构                      219
7.2.3 使用通用Flyweight架构                      221
7.2.4 使用Flyweight的实现                      222
7.3 对象池原理                      223
7.3.1 对象池和COM+                      224
7.3.2 对象池理论                      224
7.3.3 在.NET中实现ObjectPool模式                      224
7.4 多线程应用程序                      231
7.4.1 简单的线程例子                      232
7.4.2 实现单例                      232
7.4.3 使用生产者-消费者技术管理多线程问题                      242
7.5 最后的思考                      245
第8章 数据持久化                      246
8.1. NET中的序列化                      246
8.1.1. NET中的二进制对象序列化                      247
8.1.2. NET中的XML对象序列化                      249
8.1.3 序列化的问题                      251
8.2 调整并完善Serializer模式                      252
8.2.1 问外部状态：Visitor模式                      252
8.2.2 访问内部状态：Memento模式                      260
8.3 使用NHibernate进行对象/关系数据映射                      266
8.3.1 简单的NHibernate示例                      266
8.3.2 映射一对多关系                      274
8.3.3 其他类型的关联                      282
8.3.4 使用HQL                      282
8.4 最后的思考                      283
第9章 通过重构实现模式                      285
9.1 测试驱动开发与重构                      285
9.1.1 编写第一行代码                      286
9.1.2 在第一部分代码后                      286
9.1.3 重构的种类                      287
9.2 类，方法——一切都太大了                      288
9.2.1 重构Stream类                      290
9.2.2 重构Stream类的问题                      292
9.2.3 重构类而不是基类型                      293
9.3 我不理解代码                      296
9.3.1 处理未知代码                      296
9.3.2 跟踪代码                      296
9.3.3 中断代码                      297
9.4 代码似同实异                      297
9.4.1 为什么复制和粘贴代码有效                      298
9.4.2 使用Template方法重构重复的代码                      298
9.4.3 可以接受的重复                      303
9.5 时不我待                      303
9.6 我希望移除代码                      304
9.7 最后的思考                      305