C#本质论（第2版）

.1.9　小结 20
第2章　数据类型 21
2.1　基本数值类型 21
2.1.1　整数类型 21
2.1.2　浮点类型（float，clouble） 22
2.1.3　decimal类型 23
2.1.4　字面值 23
2.2　更多基本类型 27
2.2.1　布尔类型（bool） 27
2.2.2　字符类型（char） 27
2.2.3　字符串 29
2.3　null和void 34
2.3.1　null 35
2.3.2　void 35
2.4　类型的分类 37
2.4.1　值类型 37
2.4.2　引用类型 38
2.5　可空修饰符 39
2.6　数据类型之间的转换 39
2.6.1　显式转型 40
2.6.2　隐式转型 42
2.6.3　不进行转型的类型转换 43
2.7　数组 44
2.7.1　数组的声明 44
2.7.2　数组的实例化和赋值 45
2.7.3　数组的使用 48
2.7.4　字符串作为数组使用 53
2.7.5　常见错误 55
2.8　小结 55
第3章　运算符和控制流 57
3.1　运算符 57
3.1.1　一元运算符正和负 58
3.1.2　二元算术运算符 58
3.1.3　圆括号运算符 64
3.1.4　赋值运算符 64
3.1.5　递增和递减运算符 65
3.1.6　常量表达式 68
3.2　流控制概述 68
3.2.1　if语句 70
3.2.2　嵌套if 70
3.3　代码块 72
3.4　作用域 74
3.5　布尔表达式 75
3.5.1　关系运算符和相等性运算符 76
3.5.2　逻辑布尔运算符 77
3.5.3　逻辑求反运算符 78
3.5.4　条件运算符 78
3.6　按位运算符 79
3.6.1　移位运算符 80
3.6.2　按位运算符 80
3.6.3　按位赋值运算符 82
3.6.4　按位取反运算符 83
3.7　控制流语句 83
3.7.1　while和do/while循环 83
3.7.2　for循环 85
3.7.3　foreach循环 87
3.7.4　switch语句 89
3.8　跳转语句 91
3.8.1　break语句 91
3.8.2　continue语句 94
3.8.3　goto语句 95
3.9　c#预处理器指令 96
3.9.1　排除和包含代码 97
3.9.2　定义预处理器符号 98
3.9.3　生成错误和警告 98
3.9.4　关闭警告消息 99
3.9.5　nowarn:[warn list]选项 99
3.9.6　指定行号 100
3.9.7　可视编辑器提示 100
3.10　小结 101
第4章　方法和参数 103
4.1　方法的调用 104
4.1.1　命名空间 105
4.1.2　类型名称 106
4.1.3　作用域 106
4.1.4　方法名称 107
4.1.5　参数 107
4.1.6　方法返回值 107
4.1.7　语句与方法调用的比较 108
4.2　方法的声明 108
4.2.1　参数声明 110
4.2.2　方法返回值声明 110
4.3　using指令 111
4.4　main()的返回值和参数 114
4.5　参数 116
4.5.1　值参数 117
4.5.2　引用参数（ref） 118
4.5.3　输出参数（out） 119
4.5.4　参数数组（params） 120
4.6　递归 122
4.7　方法重载 124
4.8　用异常实现基本错误处理 127
4.8.1　捕捉错误 128
4.8.2　使用throw语句报告错误 134
4.9　小结 136
第5章　类 137
5.1　类的定义和实例化 140
5.2　实例字段 142
5.2.1　实例字段的声明 142
5.2.2　实例字段的访问 143
5.3　实例方法 144
5.4　使用this关键字 145
5.5　访问修饰符 151
5.6　属性 152
5.6.1　属性的声明 154
5.6.2　自动实现的属性 155
5.6.3　命名规范 157
5.6.4　提供属性验证 157
5.6.5　只读和只写属性 159
5.6.6　为getter和setter指定访问修饰符 160
5.6.7　属性作为虚字段使用 161
5.6.8　属性和方法调用不允许作为ref或out参数值使用 163
5.7　构造器 164
5.7.1　构造器的声明 164
5.7.2　默认构造器 165
5.7.3　对象初始化器 166
5.7.4　构造器的重载 167
5.7.5　使用this调用另一个构造器 168
5.8　静态 172
5.8.1　静态字段 172
5.8.2　静态方法 175
5.8.3　静态构造器 176
5.8.4　静态属性 177
5.8.5　静态类 178
5.9　扩展方法 180
5.10　封装数据 181
5.10.1　const 181
5.10.2　readonly 181
5.11　嵌套类 182
5.12　分部类 184
5.12.1　定义分部类 184
5.12.2　分部方法 185
5.13　小结 188
第6章　继承 189
6.1　派生 189
6.1.1　基类型和派生类型之间的转型 192
6.1.2　private访问修饰符 193
6.1.3　protected访问修饰符 194
6.1.4　扩展方法 195
6.1.5　单一继承 195
6.1.6　密封类 197
6.2　基类的重写 198
6.2.1　virtual修饰符 198
6.2.2　new修饰符 202
6.2.3　sealed修饰符 205
6.2.4　base成员 206
6.2.5　构造器 206
6.3　抽象类 207
6.4　一切最终都从system.object派生 212
6.5　使用is运算符验证基础类型 213
6.6　使用as运算符进行转换 213
6.7　小结 215
第7章　接口 216
7.1　接口概述 216
7.2　通过接口来实现多态性 217
7.3　接口实现 222
7.3.1　显式成员实现 223
7.3.2　隐式成员实现 225
7.3.3　显式接口实现与隐式接口实现的比较 225
7.4　“实现类”与其接口之间的转型 226
7.5　接口继承 226
7.6　多接口继承 228
7.7　接口上的扩展方法 229
7.8　通过接口来实现多重继承 230
7.9　版本控制 232
7.10　接口与类的比较 234
7.11　小结 234
第8章　值类型 235
8.1　结构 235
8.1.1　struct的初始化.. 238
8.1.2　default运算符的使用 240
8.1.3　值类型的继承和接口 240
8.2　装箱 240
8.3　枚举 245
8.3.1　枚举之间的类型兼容性 248
8.3.2　枚举和字符串之间的转换 249
8.3.3　枚举作为标志使用 249
8.4　小结 253
第9章　合式类型 254
9.1　重写object的成员 254
9.1.1　重写tostring() 254
9.1.2　重写gethashcode() 255
9.1.3　重写equals() 257
9.1.4　相等性实现的指导原则 263
9.2　运算符重载 263
9.2.1　比较运算符 263
9.2.2　二元运算符 264
9.2.3　赋值运算符与二元运算符的结合 266
9.2.4　条件逻辑运算符 266
9.2.5　一元运算符 266
9.2.6　转换运算符 267
9.2.7　转换运算符的指导原则 269
9.3　引用其他程序集 269
9.3.1　更改程序集目标 269
9.3.2　引用程序集 270
9.3.3　类型封装 270
9.4　定义命名空间 272
9.5　xml注释 274
9.5.1　将xml注释与代码构造关联到一起 275
9.5.2　生成xml文档文件 277
9.6　垃圾回收 278
9.7　资源清理 280
9.7.1　终结器 280
9.7.2　使用using语句进行确定性终结 282
9.7.3　垃圾回收和终结 284
9.7.4　资源利用和终结的指导原则 285
9.8　小结 286
第10章　异常处理 287
10.1　多异常类型 287
10.2　捕捉异常 288
10.3　常规catch块 290
10.4　异常处理的指导原则 291
10.5　定义自定义异常 293
10.6　小结 297
第11章　泛型 298
11.1　如果c#没有泛型 298
11.2　泛型类型概述 303
11.2.1　泛型类的使用 303
11.2.2　简单泛型类的定义 305
11.2.3　泛型的优点 305
11.2.4　类型参数命名的指导原则 306
11.2.5　泛型接口和struct 306
11.2.6　构造器和终结器的定义 308
11.2.7　默认值的指定 309
11.2.8　多个类型参数 310
11.2.9　嵌套泛型类型 311
11.2.10　在“类型参数”兼容的前提下，泛型类的实例之间的类型兼容性 312
11.3　约束 312
11.3.1　接口约束 314
11.3.2　基类约束 316
11.3.3　struct/class约束 317
11.3.4　多个约束 317
11.3.5　构造器约束 318
11.3.6　约束继承 318
11.4　泛型方法 322
11.4.1　类型推断 323
11.4.2　约束的指定 324
11.5　泛型的内部机制 325
11.5.1　基于值类型的泛型的实例化 327
11.5.2　基于引用类型的泛型的实例化 327
11.6　小结 328
第12章　委托和lambda表达式 329
12.1　委托概述 329
12.1.1　背景 329
12.1.2　委托数据类型 331
12.1.3　委托的内部机制 333
12.1.4　委托类型的定义 333
12.1.5　委托的实例化 334
12.2　匿名方法 338
12.3　系统定义的委托：func[] 340
12.4　lambda表达式 341
12.4.1　语句lambda 342
12.4.2　表达式lambda 344
12.4.3　外部变量 347
12.4.4　表达式树 350
12.5　小结 354
第13章　事件 355
13.1　使用multicast委托来编码observer模式 355
13.1.1　定义subscriber方法 356
13.1.2　定义publisher 357
13.1.3　连接publisher和subscriber 358
13.1.4　调用委托 359
13.1.5　检查空值 360
13.1.6　委托运算符 361
13.1.7　顺序调用 363
13.1.8　错误处理 365
13.1.9　方法返回值和传引用 367
13.2　事件 368
13.2.1　事件的作用 368
13.2.2　事件的声明 369
13.2.3　编码规范 370
13.2.4　泛型和委托 372
13.2.5　自定义事件的实现 375
13.3　小结 376
第14章　支持标准查询运算符的集合接口 377
14.1　匿名类型和隐式局部变量声明 378
14.1.1　匿名类型 378
14.1.2　隐式类型的局部变量 379
14.1.3　匿名类型和隐式局部变量的更多注意事项 380
14.2　集合初始化器 383
14.3　是什么使类成为一个集合：ienumerable[t] 385
14.3.1　foreach和数组 385
14.3.2　foreach和ienumerable[t] 386
14.3.3　foreach循环内不要修改集合 389
14.4　标准查询运算符 390
14.4.1　使用where()来筛选 393
14.4.2　使用select()来投射 394
14.4.3　推迟执行 396
14.4.4　使用orderby()和thenby()来排序 398
14.4.5　使用join()来执行内部联接 404
14.4.6　使用groupjoin()实现一对多关系 407
14.4.7　调用selectmany() 409
14.4.8　更多标准查询运算符 411
14.5　小结 414
第15章　查询表达式 416
15.1　查询表达式概述 416
15.1.1　投射 418
15.1.2　筛选 423
15.1.3　排序 424
15.1.4　let 425
15.1.5　分组 427
15.2　查询表达式作为方法调用 431
15.3　小结 432
第16章　构建自定义集合 433
16.1　更多集合接口 434
16.1.1　ilist[t]与idictionary[tkey, tvalue] 434
16.1.2　icomparable[t] 435
16.1.3　icollection[t] 437
16.2　主要集合类 437
16.2.1　列表集合：list[t] 437
16.2.2　字典集合：dictionary[tkey, tvalue] 441
16.2.3　已排序集合：sorteddictionary[tkey,tvalue]和sortedlist[t] 445
16.2.4　栈集合：stack[t] 447
16.2.5　队列集合：queue[t] 447
16.2.6　链表：linkedlist[t] 448
16.3　提供一个索引运算符 449
16.4　返回null或者空集合 452
16.5　迭代器 452
16.5.1　迭代器的定义 453
16.5.2　迭代器语法 453
16.5.3　从迭代器yield值 454
16.5.4　迭代器和状态 456
16.5.5　更多的迭代器例子 457
16.5.6　将yield return语句放到循环中 459
16.5.7　取消更多的迭代：yield break 461
16.5.8　在单个类中创建多个迭代器 463
16.5.9　yield语句的特征 464
16.6　小结 464
第17章　反射和attribute 465
17.1　反射 465
17.1.1　使用system.type访问元数据 466
17.1.2　成员调用 468
17.1.3　泛型类型上的反射 472
17.2　attribute 475
17.2.1　自定义attribute 478
17.2.2　查找attribute 478
17.2.3　使用构造器来初始化attribute 479
17.2.4　system.attributeusage-attribute 484
17.2.5　具名参数 485
17.3　小结 496
第18章　多线程处理 497
18.1　独立线程的运行和控制 499
18.1.1　线程的启动 500
18.1.2　线程管理 501
18.2　向线程传递参数 502
18.3　线程池处理 506
18.4　未处理的异常 507
18.5　同步 509
18.5.1　使用monitor来同步 511
18.5.2　使用lock关键字 512
18.5.3　lock对象的选择 514
18.5.4　为什么要避免在this和typeof(type)上锁定 514
18.5.5　将字段声明为volatile 514
18.5.6　使用system.threading.interlocked类 515
18.5.7　多个线程时的事件通知 516
18.5.8　同步设计最佳实践 517
18.5.9　更多的同步类型 518
18.6　计时器 522
18.7　小结 527
第19章　多线程处理模式 528
19.1　asynchronous results模式 528
19.1.1　asynchronous results模式概述 529
19.1.2　向轮换线程传入数据以及从轮换线程传出数据 531
19.1.3　接收线程完成通知 536
19.1.4　传递任意状态 538
19.1.5　asynchronous results小结 540
19.2　background worker模式 541
19.2.1　模式的建立 543
19.2.2　异常处理 544
19.3　windows窗体 544
19.4　小结 547
第20章　平台互操作性和不安全的代码 548
20.1　平台调用 549
20.1.1　外部函数的声明 549
20.1.2　参数的数据类型 550
20.1.3　使用ref而不是指针 551
20.1.4　为顺序布局使用structlayoutattribute 551
20.1.5　错误处理 552
20.1.6　使用safehandle 554
20.1.7　外部函数的调用 556
20.1.8　用包装简化api调用 559
20.1.9　函数指针映射到委托 560
20.1.10　指导原则 560
20.2　指针和地址 560
20.2.1　不安全的代码 560
20.2.2　指针的声明 561
20.2.3　指针的赋值 563
20.2.4　指针的解引用 565
20.2.5　访问被引用物的类型的成员 566
20.3　小结 567
第21章　cli 569
21.1　cli的定义 569
21.2　cli实现 570
21.3　c#编译成机器码 571
21.4　运行时 572
21.4.1　垃圾回收 573
21.4.2　.net的垃圾回收 573
21.4.3　类型安全 574
21.4.4　代码访问安全性 574
21.4.5　平台可移植性 574
21.4.6　性能 575
21.5　应用程序域 576
21.6　程序集、清单和模块 576
21.7　公共中间语言 578
21.8　公共类型系统 578
21.9　公共语言规范 579
21.10　基类库 579
21.11　元数据 579
21.12　小结 580
附录a　下载和安装c#编译器与cli平台 581
附录b　完整源代码清单 583
附录c　c# 3.0主题... 609

.　　标准查询操作符（参见第14章）；
　　查询表达式（参见第15章）。..
　　考虑到许多人还不熟悉这些主题，本书围绕它们展开了详细的讨论。涉及高级C#开发的还有“指针”这一主题，该主题将在第21章讨论。就算是有经验的C#开发者，也经常不能很好地理解这一主题。
　　本书特色
　　本书是一本语言参考书，它遵循核心C# Language 3.0 Specification。为了帮助读者理解各种C#结构，书中用大量例子演示了每一种特性，而且为每个概念都提供了相应的指导原则和最佳实践，以确保代码能顺利编译、避免留下隐患，并获得最佳的可维护性。
　　为了增强可读性，所有代码均进行了特殊格式处理，而且每一章的内容都使用思维导图来概括。
　　代码示例
　　本书大多数代码片段都能在公共语言基础结构（Common Language Infrastructure，CLI）的任何实现上运行，其中包括Mono、Rotor和Microsoft .NET平台。我很少使用平台或厂商特有的库，除非需要解释只和那些平台有关的某些重要概念（例如，解释如何正确处理Windows单线程用户界面）。附录C中介绍了那些只适用于C#3.0的代码。
　　下面是一个示例代码清单。
　　代码清单1-17在代码中添加注释
　　下面简单介绍一下代码格式。
　　注释以斜体表示。
　　关键字加粗。
　　static void Main()
　　有的代码被突出显示，是为了指明这些代码与之前列出的有所区别，或是为了演示正文中介绍的概念。
　　突出显示的内容可能是一整行，也可能仅仅是一行中的几个字符。
　　不完整的程序清单包含一个省略号，指出无关的代码已省略。
　　在代码清单之后，列出了对应的控制台输出，如下所示：
　　输出1-4
　　HeyYou.exe
　　Hey you!
　　Enter your first name: Inigo
　　Enter your last name: Montoya
　　用户在执行程序时输入的内容显示为斜体。
　　虽然提供完整的代码示例可以方便你在自己的程序中使用它们，但这样做会分散你对特定主题的注意力。因此，你需要自行修改代码示例，然后才能把它们集成到自己的程序中。此外，书中的代码示例没有显式地包含using System语句；在所有的例子中，这个语句都是必需的。
　　可以从以下网址下载示例代码。
　　http://mark.michaelis.net/EssentialCSharp
　　分类解说
　　根据自己的编程水平，书中特殊的代码块和页面边缘的灰色竖线条可以帮你轻松地找到适合自己的内容。
　　初学者主题：特别针对入门级程序员提供的定义或解释。
　　高级主题：可以让有经验的开发者将注意力放在他们最关心的内容上。
　　标注：用标注框 来强调关键原则，使读者对其重要性一目了然。
　　语言对比：分散在正文中的补充内容，描述了C#和其他语言的关键差异，为熟悉其他语言的读者提供指引。
　　思维导图
　　每一章开头都包含一幅“思维导图 ”。作为一个提纲，它的作用是为读者提供对每章内容的一个快速参考。下面是一个例子（摘自第5章）。
　　每一章的主题显示在思维导图的中心，高级主题围绕这个中心展开。利用思维导图，读者可以方便地搭建自己的知识体系，可以从一个主题出发，更清楚地理解其周边的各个具体概念，避免中途纠缠于一些不相干的枝节问题。
　　本书内容组织
　　总的来说，软件工程的宗旨就是对复杂性进行管理。本书正是基于这个宗旨来组织内容的。第1章～第4章介绍的是结构化编程，学习了这些内容后，你可以立即开始写一些功能简单的代码。第5章～第9章介绍了C#的面向对象构造，新手应在完全理解了这几章的内容之后，再开始接触本书其余部分的更高级主题。第11章～第13章介绍了更多用于降低复杂性的构造，讲解了当今几乎所有程序都要用到的通用设计模式。在理解了它们之后，你可以更加轻松地理解如何通过反射和attribute来实现动态编程。在后续的章节中，将广泛运用反射和attribute来实现线程处理和互操作性。
　　本书最后专门用一章（第21章）来讲述CLI。这一章在开发平台的背景下对C#语言进行了描述。之所以要放到最后，是因为它并不是C#特有的，而且不会涉及语法和编程风格问题。不过，本章适合在任何时候阅读，或许最恰当的时机是在阅读了本书的第1章之后。
　　下面是每一章的内容提要。（星号代表针对C# 3.0的内容专门撰写的全新的一章，加黑的章标题表明那一章含有C# 3.0的内容。）
　　第1章——C#概述：这一章在展示了一个用C#编写的HelloWorld程序之后，进一步剖析了C#。这应当能使读者熟悉C#程序的“外观和感觉”。这一章提供了让读者编译和调试自己的程序所需的足够多的细节。此外，这一章还简单描述了执行C#程序的上下文及其中间语言（intermediate language，IL）。
　　第2章——数据类型：任何有用的程序都要处理数据，这一章介绍了C#的两种基本数据类型，即值类型和引用类型，另外还讨论了类型间的转换以及C#对数组的支持。
　　第3章——运算符和控制流：计算机擅长重复性操作，为了利用计算机的这个能力，需要知道如何在自己的程序中添加循环和条件逻辑。这一章还讨论了C#运算符、数据转换以及预处理器指令。
　　第4章——方法和参数：这一章研究了有关方法及其参数的细节，其中包括通过参数来传值、传引用和返回数据。C#不支持默认参数，这一章解释了背后的原因，并讨论了相同的功能如何实现。
　　第5章——类：前面已经学过了类的基本构成元素，这一章将这些构造合并到一起，从而获得具有完整功能的类型。类是面向对象技术的核心，它为一“类”对象定义了一个模板。
　　第6章——继承：虽然继承是许多开发者的基本编程手段，但C#提供了一些独一无二的构造，比如new修饰符。这一章讨论了继承语法的细节，其中包括重写（overriding）。
　　第7章——接口：这一章展示了如何利用接口来定义类之间的“可以进行版本控制的交互契约”（versionable interaction contract）。C#同时包含显式和隐式的接口成员实现，可以实现一个额外的封装等级，这是其他大多数语言所不支持的。
　　第8章——值类型：尽管不如引用类型那么流行，但有些情况下仍然有必要定义行为类似于C#内置基本类型的值类型。这一章要介绍如何定义结构（structure），同时揭示它们的特性。
　　第9章——合式类型：这一章讨论了一些更高级的类型定义，解释了如何实现运算符，比如“±”和转型运算符，并描述了如何将多个类封装到一个库中。除此之外，这一章还演示了如何定义命名空间和XML注释，并讨论了如何基于垃圾回收机制来设计令人满意的类。
　　第10章——异常处理：这一章是对第4章引入的异常处理机制的一个延伸讨论，描述了如何利用异常层次结构来创建自定义异常。此外，它还强调了异常处理的一些最佳实践。
　　第11章——泛型：从某种意义上说，泛型或许是C# 1.0缺少的一个最重要的特性。这一章全面讨论了这个新特性。
　　*第12章——委托和Lambda表达式：正是因为委托，才使C#与其前身语言（C和C++等）有了显著的不同，它定义了在代码中处理事件的模式。这几乎完全消除了写轮询例程的必要。Lambda表达式是使C# 3.0的LINQ成为可能的关键概念。通过这一章的学习，你将知道Lambda表达式是在委托的基础上构建起来的，它提供了比委托更加优雅和简洁的语法。本章的内容是第14章讨论的新的集合API的基础。
　　第13章——事件：封装起来的委托（称为事件）是公共语言运行时（Common Language Runtime，CLR）的一个核心构造。本章还探讨了匿名方法，它是在C# 2.0中增加的一个特性。
　　*第14章——支持标准查询运算符的集合接口：当讨论到新的Enumerable类的扩展方法时，你将了解C# 3.0中引入的一些简单的、同时又非常强大的改变。Enumerable类使一个全新的集合API成为可能，这个API称为“标准查询运算符”，在这一章进行了详细讨论。
　　*第15章——查询表达式：如果只使用标准查询操作符，就会形成让人难以辨认的长语句。然而，查询表达式提供了一种类似SQL风格的语法，能够有效地解决这个问题。这一章会详细讨论这种表达式。
　　第16章——构建自定义集合：在构建用于操纵业务对象的自定义API时，经常都需要创建自定义的集合。本章讨论了具体如何做；同时，还介绍了能使自定义集合的构建变得更简单的上下文关键字。
　　第17章——反射和attribute：20世纪80年代末，程序结构的思维模式发生了根本性的变化，面向对象的编程是这个变化的基础。类似地，attribute使说明性编程和嵌入元数据成为可能，因而引入了一种新的思维模式。这一章探讨了attribute的方方面面，并讨论了如何通过反射机制来获取它们。这一章还讨论了如何通过基类库（Base Class Library，BCL）中的序列化框架来实现文件的输入和输出。
　　第18章——多线程处理：大多数现代的程序都要求使用线程来执行长时间运行的任务，还要确保对并发的事件进行快速响应。随着程序变得越来越复杂，必须采取其他措施来保护这些高级环境中的数据。多线程应用程序的编写是一项复杂的任务。这一章讨论了如何操纵线程，并讲述了如何采取一些必要的措施来防止将多线程应用程序弄得一团糟。
　　第19章——多线程处理模式：这一章以第18章为基础，演示了如何利用一些内建的线程处理模式来简化对多线程代码的显式控制。
　　第20章——平台互操作性和不安全的代码：必须认识到的是，C#是相对年轻的一种语言，许多现有的代码是用其他语言写成的。为了用好这些现有的代码，C#通过P/Invoke提供了对互操作性（非托管代码的调用）的支持。除此之外，C#允许使用指针，也允许执行直接内存操作。虽然使用了指针的代码要求特殊的权限才能运行，但它具有与C风格的API完全兼容的能力。
　　第21章——CLI：事实上，C#被设计成一种在CLI的顶部工作的最有效的编程语言。这一章讨论了C#程序与底层“运行时”及其规范的关系。
　　附录A——下载和安装C#编译器与CLI平台：这个附录介绍了如何安装Microsoft .NET和Mono，它们是编译和运行C#代码的基础平台。
　　附录B——完整源代码清单：本书许多章都将源代码分散到多个代码清单中。如果代码清单较大，就会使读者难以跟进。这个附录将第3章、第11章、第12章、第14章和第17章的代码清单整合成完整的程序，便于读者从整体上理解各个单独的代码清单。
　　附录C——C# 3.0主题：提供了所有C# 3.0主题的快速参考，旨在帮助C# 2.0程序员快速熟悉3.0的新特性。
　　希望本书成为你学习和掌握C#技能的一个好帮手。另外，希望以后需要了解C#的一些特殊主题及其内部工作原理的时候，本书也是一本出色的参考书。
　　致谢
　　世界上没有任何一本书是作者单枪匹马就能出版的，在此，我要向此过程中帮助过我的所有人致以衷心的感谢。
　　表达感激之情的顺序并不重要，我是想到谁就感谢谁。到现在为止，为了让我顺利完成此书，我的家人做出了巨大的牺牲。在Banjamin、Hanna和Abigail眼中，他们的爸爸经常因为此书而无暇顾及他们，但Elisabeth承受的更多。家里的大事小事全靠她一个人，她独自承担家庭的重任。亲爱的，辛苦了！
　　为保证本书技术上的准确性，许多技术编辑对本书中的各章都进行了仔细审阅。我常常惊讶于他们的认真程度，任何不易察觉的小错误都逃不过他们的火眼金睛，他们是Eric Lippert、Michael Stokesbary、Paul Bramsman、Robert Stokesbary、Nicholas Paldino、Anson Horton、Angelika Langer、Gerard Frantz、Doug Dechow、Jon Skeet、Stephen Toub、John Timney。
　　特别要感谢Michael，在我编写本书期间，他在编辑技术内容和完善本书结构方面，给予我莫大的帮助，更不用说他给予我的珍贵的友情。同时，我还要特别感谢两位C# MVP（微软最有价值专家）Nicholas和John，他们对这种编程语言某些方面的了解仅次于C#开发团队。
　　Eric给了我太多的惊奇。他对C#术语的掌握程度令人“望而生畏”，我非常欣赏他的修改，尤其是这反映出他在术语方面力求完美。他对C# 3.0相关章节做了不小的改进，我唯一感到遗憾的就是未能让他审阅所有章节。
　　Paul和Robert是第二版的核心技术审稿人，他们耐心地用C# 3.0编译器重新编译并运行所有的代码清单。这是非常繁重的一个工作，感谢你们找出错误并提出建议。
　　此外，还要感谢Addison-Wesley的所有员工，感谢他们在与我合作期间表现出来的耐心，容忍我将注意力频频转移到书稿之外的其他事情。感谢Curt Johnson和Joan Murray。还要感谢Joan每周一次的催稿电话——好吧，这至少让我在“心有旁骛”的时候有了一些“负罪感”。
　　最后，感谢微软公司开发部的Prashant Sridharan。是他促使我开始动笔写作本书，而且他提供的大量素材使我难以置信地占尽了先机。...
　　——Mark Michaelis
　　http://mark.michaelis.net
　　

.　　查询表达式
　　在本书中，LINQ之旅的起点是Mark对一些重要的C# 2.0技术的讲解，比如泛型和委托。然后，他会手把手地教你如何从委托迁移到Lambda。他解释了为什么Lambda会成为C# 3.0的一部分，及其在LINQ中扮演的重要角色。他还讲解了扩展方法，以及在实现LINQ查询运算符时，这些扩展方法所扮演的角色。
　　在详细解释查询表达式时，他对C# 3.0新特性的关注达到了顶峰。在此期间，他讲述了查询表达式的关键特性，比如投射、筛选、排序、分组和为了理解LINQ而需要掌握的重要概念。然后，他解释了如何将查询表达式转换成实际由编译器来执行的LINQ查询方法语法。等你阅读完有关查询表达式的内容之后，应该就已经掌握了理解LINQ需要的全部知识，并可以在自己的程序中使用这一重要技术了。
　　如果你想成为一名C#开发者，或者想提高现有的C#编程技能，一本切中主题、精心组织的书是最为有用的。你现在就拿着这样的一本书。像这样的一本书，首先会让你掌握语言是如何工作的，然后在你需要快速找到答案的时候，它又可以作为一本参考书供你使用。对于那些想要了解Microsoft最新技术的开发者，这本书也会成为你的良师益友，帮助你理清不断变化的技术趋势。究竟哪种语言正在快速演变成当今最高级、最重要的编程语言？本书为你展示了最准确、最新颖的观点。
　　Charlie Calvert
　　微软Visual C#社区项目经理...
　　2008年4月