.NET2.0模式開發(fā)實踐

第1章 面向對象編程的實質                    1
1.1 理解類型                      1
1.2 模塊化與可重用代碼                      3
1.3 利用作用域控制訪問                      5
1.4 理解繼承                      7
1.4. 1class與struct在繼承上的區(qū)別                      8
1.4.2 簡單的繼承                      11
1.4.3 利用虛函數(shù)繼承                      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章 日志、錯誤與測試驅動開發(fā)                      22
2.1 日志管理                      22
2.1.1 簡單的log4net例子                      22
2.1.2 利用ILog接口生成消息                      24
2.1.3 管理配置文件                      25
2.1.4 建立一個現(xiàn)實的配置                      27
2.1.5 實現(xiàn)ToString                    34
2.2 實現(xiàn)異常處理                      35
2.2.1 錯誤與異常分類                      35
2.2.2 實現(xiàn)錯誤策略                      37
2.2.3 實現(xiàn)異常策略                      44
2.3 使用NUnit來做測試驅動開發(fā)                      48
2.3.1 理解測試驅動開發(fā)                      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 測試驅動開發(fā)                      58
3.2 實現(xiàn)Bridge模式                      62
3.2.1 使用接口時留有選擇余地                      63
3.2.2 過猶不及                      64
3.2.3 關于.NET1.x                    65
3.3 Bridge模式實現(xiàn)變種                      66
3.3.1 實現(xiàn)應用程序邏輯                      66
3.3.2 控制器接口                      69
3.3.3 實現(xiàn)默認的基類                      70
3.3.4 接口和類的設計決策                      73
3.4 使用Factory模式實例化類型                      77
3.4.1 需要幫助類型                      77
3.4.2 實現(xiàn)插件架構                      78
3.4.3 根據(jù)計劃創(chuàng)建對象                      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 電視機選擇系統(tǒng)的架構                      86
4.2.3 電視機選擇系統(tǒng)的實現(xiàn)                      87
4.2.4 關于PipesandFilters模式的幾點思考                      95
4.3 Client-Dispatcher-Server模式                      96
4.3.1 定義Client-Dispatcher-Server模式的架構                      97
4.3.2 靜態(tài)分配器架構                      98
4.3.3 動態(tài)分配器架構                      99
4.3.4 架構Client-Dispatcher-Server模式                      101
4.3.5 實現(xiàn)程序集目錄解析器                      103
4.3.6 實現(xiàn)Web服務解析器                      109
4.4 Micro-Kernel模式                      111
4.4.1 微內(nèi)核的架構                      111
4.4.2 隱藏微內(nèi)核的細節(jié)                      112
4.4.3 設計微內(nèi)核                      113
4.4.4 微內(nèi)核實現(xiàn)細節(jié)                      114
4.4.5 構建簡單的銀行應用程序                      114
4.4.6 關于Micro-Kernel模式的思考                      120
4.5 最后的思考                      120
第5章 實現(xiàn)成組的組件                      121
5.1 兩個傳統(tǒng)的面向對象錯誤                      121
5.1.1 屬性和烤箱溫度控制                      122
5.1.2 繼承和基類的脆弱性問題                      124
5.2 示例應用：翻譯程序                      128
5.2.1 快速編寫一個簡陋的應用程序                      128
5.2.2 重構代碼                      130
5.2.3 重構并且實現(xiàn)Bridge和Factory                      130
5.2.4 實現(xiàn)Mediator模式                      132
5.2.5 實現(xiàn)Template模式                      137
5.2.6 實現(xiàn)Adapter模式                      142
5.2.7 關于翻譯程序的最后思考                      146
5.3 為應用程序添加多語言支持                      146
5.3.1 想想看：Decorator還是Composite                      146
5.3.2 實現(xiàn)ChainofResponsibility模式                      147
5.3.3 實現(xiàn)Command模式                      151
5.3.4 實現(xiàn)Composite模式                      154
5.3.5 實現(xiàn)Decorator模式                      156
5.3.6 實現(xiàn)State模式                      159
5.3.7 實現(xiàn)Strategy模式                      164
5.3.8 實現(xiàn)翻譯語言的動態(tài)選擇                      165
5.4 最后的思考                      166
第6章 編寫算法                      168
6.1 不做修改的功能模仿                      168
6.1.1 實現(xiàn)Proxy模式                      169
6.1.2 使用仿函數(shù)增強類型                      170
6.1.3 為集合創(chuàng)建泛型仿函數(shù)架構                      178
6.2 構建電影票應用程序                      181
6.2.1 從基礎開始                      181
6.2.2 計算票的銷售額                      182
6.2.3 讀取銷售額數(shù)據(jù)                      184
6.2.4 使用null的問題                      186
6.2.5 更為簡單的買票方法：使用Facade模式                      189
6.3 使用多態(tài)管理擴展                      193
6.3.1 實現(xiàn)StaticExtension模式                      193
6.3.2 實現(xiàn)DynamicExtension模式                      198
6.3.3 擴展、類型轉換以及它們的意義                      202
6.4 使用Iterator模式遍歷數(shù)據(jù)                      203
6.4.1 使用C#2.0實現(xiàn)Iterator模式                      203
6.4.2 在迭代器中使用仿函數(shù)                      204
6.5 最后的思考                      205
第7章 高效代碼                      206
7.1 不可變類是高效的類                      206
7.1.1 為什么不可變類具有一致性                      206
7.1.2 為什么不可變類是可伸縮的                      213
7.1.3 一些使用不可變類的經(jīng)驗                      216
7.2 在Flyweight模式中使用不可變類                      217
7.2.1 Flyweight模式的例子                      217
7.2.2 通用的Flyweight架構                      219
7.2.3 使用通用Flyweight架構                      221
7.2.4 使用Flyweight的實現(xiàn)                      222
7.3 對象池原理                      223
7.3.1 對象池和COM+                      224
7.3.2 對象池理論                      224
7.3.3 在.NET中實現(xiàn)ObjectPool模式                      224
7.4 多線程應用程序                      231
7.4.1 簡單的線程例子                      232
7.4.2 實現(xiàn)單例                      232
7.4.3 使用生產(chǎn)者-消費者技術管理多線程問題                      242
7.5 最后的思考                      245
第8章 數(shù)據(jù)持久化                      246
8.1. NET中的序列化                      246
8.1.1. NET中的二進制對象序列化                      247
8.1.2. NET中的XML對象序列化                      249
8.1.3 序列化的問題                      251
8.2 調(diào)整并完善Serializer模式                      252
8.2.1 問外部狀態(tài)：Visitor模式                      252
8.2.2 訪問內(nèi)部狀態(tài)：Memento模式                      260
8.3 使用NHibernate進行對象/關系數(shù)據(jù)映射                      266
8.3.1 簡單的NHibernate示例                      266
8.3.2 映射一對多關系                      274
8.3.3 其他類型的關聯(lián)                      282
8.3.4 使用HQL                      282
8.4 最后的思考                      283
第9章 通過重構實現(xiàn)模式                      285
9.1 測試驅動開發(fā)與重構                      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