深入理解C# 原书第2版PDF电子书下载

第一部分 基础知识 2

第1章C#开发的进化史 2

1.1从简单的数据类型开始 3

1.1.1 C# 1中定义的产品类型 3

1.1.2 C# 2中的强类型集合 4

1.1.3 C# 3中自动实现的属性 5

1.1.4 C#4中的命名实参 6

1.2排序和过滤 7

1.2.1按名称对产品进行排序 7

1.2.2查询集合 10

1.3处理未知数据 11

1.3.1表示未知的价格 12

1.3.2可选参数和默认值 12

1.4 LINQ简介 13

1.4.1查询表达式和进程内查询 13

1.4.2查询XML 14

1.4.3 LINQ to SQL 15

1.5 COM和动态类型 16

1.5.1简化COM互操作 16

1.5.2与动态语言互操作 17

1.6剖析.NET平台 18

1.6.1 C#语言 18

1.6.2运行时 19

1.6.3框架库 19

1.7怎样写出超炫的代码 19

1.7.1采用代码段形式的全能代码 20

1.7.2教学代码不是产品代码 21

1.7.3你的新朋友：语言规范 21

1.8小结 21

第2章C# 1所搭建的核心基础 23

2.1委托 23

2.1.1简单委托的构成 24

2.1.2合并和删除委托 28

2.1.3对事件的简单讨论 29

2.1.4委托小结 30

2.2类型系统的特征 31

2.2.1 C#在类型系统世界中的位置 31

2.2.2 C# 1的类型系统在什么时候不够用 34

2.2.3类型系统特征总结 36

2.3值类型和引用类型 36

2.3.1现实世界中的值和引用 36

2.3.2值类型和引用类型基础知识 37

2.3.3走出误区 38

2.3.4装箱和拆箱 40

2.3.5值类型和引用类型小结 41

2.4 C# 1之外：构建于坚实基础之上的新特性 41

2.4.1与委托有关的特性 41

2.4.2与类型系统有关的特性 43

2.4.3与值类型有关的特性 45

2.5小结 46

第二部分C# 2：解决C# 1的问题 48

第3章 用泛型实现参数化类型 48

3.1为什么需要泛型 49

3.2日常使用的简单泛型 50

3.2.1通过例子来学习：泛型字典 50

3.2.2泛型类型和类型参数 52

3.2.3泛型方法和判读泛型声明 55

3.3深化与提高 58

3.3.1类型约束 58

3.3.2泛型方法类型实参的类型推断 62

3.3.3实现泛型 63

3.4高级泛型 68

3.4.1静态字段和静态构造函数 69

3.4.2 JIT编译器如何处理泛型 70

3.4.3泛型迭代 72

3.4.4反射和泛型 74

3.5泛型在C#和其他语言中的限制 78

3.5.1泛型可变性的缺乏 78

3.5.2缺乏操作符约束或者“数值”约束 82

3.5.3缺乏泛型属性、索引器和其他成员类型 83

3.5.4同C++++模板的对比 84

3.5.5和Java泛型的对比 85

3.6小结 86

第4章 可空类型 88

4.1没有值时怎么办 88

4.1.1为什么值类型的变量不能是null 89

4.1.2在C# 1中表示空值的模式 89

4.2 System.Nullable<T>和System.Nullable 91

4.2.1 Nullable<T>简介 91

4.2.2 Nullable<T>装箱和拆箱 94

4.2.3 Nullable<T>实例的相等性 95

4.2.4来自非泛型Nullable类的支持 96

4.3 C# 2为可空类型提供的语法糖 96

4.3.1？修饰符 97

4.3.2使用null进行赋值和比较 98

4.3.3可空转换和操作符 99

4.3.4可空逻辑 102

4.3.5对可空类型使用as操作符 103

4.3.6空合并操作符 104

4.4可空类型的新奇用法 106

4.4.1尝试一个不使用输出参数的操作 107

4.4.2空合并操作符让比较不再痛苦 108

4.5小结 111

第5章 进入快速通道的委托 112

5.1向笨拙的委托语法说拜拜 113

5.2方法组转换 114

5.3协变性和逆变性 115

5.3.1委托参数的逆变性 116

5.3.2委托返回类型的协变性 117

5.3.3不兼容的风险 118

5.4使用匿名方法的内联委托操作 119

5.4.1从简单的开始：处理一个参数 119

5.4.2匿名方法的返回值 121

5.4.3忽略委托参数 123

5.5在匿名方法中捕捉变量 124

5.5.1定义闭包和不同的变量类型 124

5.5.2测试被捕获的变量的行为 126

5.5.3捕获变量到底有什么用处 127

5.5.4捕获变量的延长生存期 127

5.5.5局部变量实例化 128

5.5.6共享和非共享的变量混合使用 130

5.5.7捕获变量的使用规则和小结 132

5.6小结 133

第6章 实现迭代器的捷径 134

6.1 C# 1：手写迭代器的痛苦 135

6.2 C# 2：利用yield语句简化迭代器 137

6.2.1迭代器块和yield return简介 137

6.2.2观察迭代器的工作流程 139

6.2.3进一步了解迭代器执行流程 141

6.2.4具体实现中的奇特之处 144

6.3真实的例子：迭代范围值 145

6.3.1迭代时刻表中的日期 145

6.3.2迭代文件中的行 146

6.3.3使用迭代器块和谓词对项进行延迟筛选 148

6.4使用CCR实现伪同步代码 150

6.5小结 152

第7章 结束C# 2的讲解：最后的一些特性 153

7.1分部类型 154

7.1.1在多个文件中创建一个类型 154

7.1.2分部类型的使用 156

7.1.3 C# 3独有的分部方法 157

7.2静态类型 159

7.3独立的取值方法/赋值方法属性访问器 161

7.4命名空间别名 162

7.4.1限定的命名空间别名 163

7.4.2全局命名空间别名 164

7.4.3外部别名 164

7.5 Pragma指令 166

7.5.1警告pragma 166

7.5.2校验和pragma 167

7.6非安全代码中的固定大小的缓冲区 167

7.7把内部成员暴露给选定的程序集 169

7.7.1在简单情况下的友元程序集 169

7.7.2为什么使用InternalsVisibleTo 170

7.7.3InternalsVisibleTo和签名程序集 170

7.8小结 171

第三部分C# 3：革新写代码的方式 174

第8章 用智能的编译器来防错 174

8.1自动实现的属性 175

8.2隐式类型的局部变量 176

8.2.1用var声明局部变量 177

8.2.2隐式类型的限制 178

8.2.3隐式类型的优缺点 179

8.2.4建议 180

8.3简化的初始化 180

8.3.1定义示例类型 181

8.3.2设置简单属性 182

8.3.3为嵌入对象设置属性 183

8.3.4集合初始化列表 184

8.3.5初始化特性的应用 186

8.4隐式类型的数组 187

8.5匿名类型 188

8.5.1第一次邂逅匿名类型 188

8.5.2匿名类型的成员 190

8.5.3投影初始化列表 191

8.5.4重点何在 192

8.6小结 193

第9章Lambda表达式和表达式树 194

9.1作为委托的Lambda表达式 195

9.1.1准备工作：Func<…>委托类型简介 195

9.1.2第一次转换成Lambda表达式 196

9.1.3用单一表达式作为主体 197

9.1.4隐式类型的参数列表 197

9.1.5单一参数的快捷语法 198

9.2使用List<T>和事件的简单例子 199

9.2.1对列表进行筛选、排序并设置其他操作 199

9.2.2在事件处理程序中进行记录 201

9.3表达式树 202

9.3.1在程序中构建表达式树 202

9.3.2将表达式树编译成委托 204

9.3.3将C# Lambda表达式转换成表达式树 205

9.3.4位于LINQ核心的表达式树 208

9.3.5 LINQ之外的表达式树 209

9.4类型推断和重载决策发生的改变 211

9.4.1改变的起因：精简泛型方法调用 211

9.4.2推断匿名函数的返回类型 212

9.4.3分两个阶段进行的类型推断 213

9.4.4选择正确的被重载的方法 217

9.4.5类型推断和重载决策 218

9.5小结 219

第10章 扩展方法 220

10.1未引入扩展方法之前的状态 221

10.2扩展方法的语法 223

10.2.1声明扩展方法 223

10.2.2调用扩展方法 224

10.2.3扩展方法是怎样被发现的 225

10.2.4在空引用上调用方法 226

10.3 .NET 3.5中的扩展方法 227

10.3.1从Enumerable开始起步 228

10.3.2用Where筛选并将方法调用链接到一起 229

10.3.3插曲：似曾相识的Where方法 231

10.3.4用Select方法和匿名类型进行投影 232

10.3.5用OrderBy方法进行排序 232

10.3.6涉及链接的实际例子 234

10.4使用思路和原则 235

10.4.1“扩展世界”和使接口更丰富 235

10.4.2流畅接口 236

10.4.3理智使用扩展方法 237

10.5小结 238

第11章 查询表达式和LINQ to Objects 240

11.1 LINQ介绍 241

11.1.1 LINQ中的基础概念 241

11.1.2定义示例数据模型 245

11.2简单的开始：选择元素 246

11.2.1以数据源作为开始,以选择作为结束 246

11.2.2作为查询表达式基础的编译器转换 247

11.2.3范围变量和重要的投影 249

11.2.4 Cast、 OfType和显式类型的范围变量 251

11.3对序列进行过滤和排序 252

11.3.1使用where子句进行过滤 253

11.3.2退化的查询表达式 253

11.3.3使用orderby子句进行排序 254

11.4 let子句和透明标识符 256

11.4.1用let来进行中间计算 256

11.4.2透明标识符 257

11.5联接 258

11.5.1使用join子句的内联接 258

11.5.2使用join… into子句进行分组联接 262

11.5.3使用多个from子句进行交叉联接和合并序列 264

11.6分组和延续 267

11.6.1使用group … by子句进行分组 267

11.6.2查询延续 270

11.7在查询表达式和点标记之间作出选择 272

11.7.1需要使用点标记的操作 273

11.7.2选择点标记 273

11.7.3选择查询表达式 274

11.8小结 275

第12章 超越集合的LINQ 276

12.1使用LINQ to SQL查询数据库 277

12.1.1数据库和模型 277

12.1.2用查询表达式访问数据库 279

12.1.3包含联接的查询 281

12.2用IQueryable和IQueryProvider进行转换 283

12.2.1IQueryable<T>和相关接口的介绍 283

12.2.2模拟接口实现来记录调用 285

12.2.3把表达式粘合在一起：Queryable的扩展方法 287

12.2.4模拟实际运行的查询提供器 289

12.2.5包装IQueryable 290

12.3 LINQ友好的API和LINQ to XML 290

12.3.1 LINQ to XML中的核心类型 290

12.3.2声明式构造 292

12.3.3查询单个节点 294

12.3.4合并查询操作符 296

12.3.5与LINQ和谐共处 297

12.4用并行LINQ代替LINQ to Objects 297

12.4.1在单线程中绘制曼德博罗特集 297

12.4.2 ParallelEnumerable、Parallel-Query和AsParallel 299

12.4.3调整并行查询 300

12.5使用LINQ to Rx反转查询模型 301

12.5.1IObservable<T>和 IObserver<T> 302

12.5.2简单地开始 303

12.5.3查询可观察对象 304

12.5.4意义何在 306

12.6扩展LINQ to Objects 306

12.6.1设计和实现指南 307

12.6.2示例扩展：选择随机元素 308

12.7小结 309

第四部分C# 4：良好的交互性 312

第13章 简化代码的微小修改 312

13.1可选参数和命名实参 312

13.1.1可选参数 313

13.1.2命名实参 317

13.1.3两者相结合 321

13.2改善COM互操作性 324

13.2.1在C# 4之前操纵Word是十分恐怖的 325

13.2.2可选参数和命名实参的复仇 325

13.2.3按值传递ref参数 326

13.2.4调用命名索引器 327

13.2.5链接主互操作程序集 328

13.3接口和委托的泛型可变性 330

13.3.1可变性的种类：协变性和逆变性 331

13.3.2在接口中使用可变性 332

13.3.3在委托中使用可变性 334

13.3.4复杂情况 335

13.3.5限制和说明 336

13.4对锁和字段风格的事件的微小改变 339

13.4.1健壮的锁 339

13.4.2字段风格的事件 340

13.5小结 341

第14章 静态语言中的动态绑定 342

14.1何谓，何时，为何，如何 343

14.1.1何谓动态类型 343

14.1.2动态类型什么时候有用，为什么 344

14.1.3 C# 4如何提供动态类型 345

14.2关于动态的快速指南 345

14.3动态类型示例 348

14.3.1 COM和Office 348

14.3.2动态语言 350

14.3.3纯托管代码中的动态类型 353

14.4幕后原理 358

14.4.1 DLR简介 358

14.4.2 DLR核心概念 360

14.4.3 C#编译器如何处理动态 362

14.4.4更加智能的C#编译器 365

14.4.5动态代码的约束 368

14.5实现动态行为 370

14.5.1使用Expandoobject 370

14.5.2使用DynamicObject 374

14.5.3实现IDynamicMetaobject-Provider 380

14.6小结 383

第15章 使用契约让代码更加清晰 385

15.1未引入代码契约之前的状态 386

15.2代码契约 387

15.2.1前置条件 388

15.2.2后置条件 389

15.2.3固定条件 390

15.2.4断言和假设 392

15.2.5旧式契约 393

15.3使用ccrewrite和ccrefgen重写二进制 394

15.3.1简单重写 394

15.3.2契约继承 395

15.3.3契约引用程序集 398

15.3.4失败行为 399

15.4静态检查 401

15.4.1开始静态检查 401

15.4.2隐式职责 403

15.4.3有选择性的检查 406

15.5使用ccdocgen将契约文档化 408

15.6契约实战 410

15.6.1契约中有什么 410

15.6.2如何开始 411

15.6.3无处不在的选项 412

15.7小结 414

第16章 何去何从 415

16.1 C#——传统与现代的结合 415

16.2计算机科学和.NET 416

16.3计算机世界 417

16.4再会 417

附录A LINQ标准查询操作符 419

附录B .NET中的泛型集合 430

附录C版本总结 440