(特价书)C#从现象到本质

1.5.4　即时编译（JIT） 33
1.5.5　运行时的验证 34
1.5.6　Visual Studio的编译模式与本地代码的优化 34
1.5.7　托管代码与非托管代码的互操作性 35
1.6　CLR启动与Hello World的运行 36
1.7　本章小结 37
1.8　思考题 37
第2章　C#类型基础（上） 38
2.1　公共类型系统 38
2.2　堆与栈 40
2.2.1　堆 40
2.2.2　栈 41
2.3　引用类型的内存分配 42
2.3.1　字段的对齐 44
2.3.2　同步块索引 45
2.3.3　方法表指针和类型对象 45
2.3.4　静态字段和属性 46
2.4　使用WinDbg探查内存 46
2.4.1　WinDbg简易命令速查 47
2.4.2　使用WinDbg探查引用类型 47
2.4.3　引用类型的复制 52
2.5　值类型 53
2.5.1　基元类型 54
2.5.2　值类型的内存分配 54
2.5.3　值类型的构造函数 56
2.5.4　何时考虑使用值类型 57
2.5.5　值类型是密封的 58
2.5.6　值类型和引用类型的区别与联系 58
2.5.7　嵌套：值类型与引用类型 58
2.6　装箱和拆箱 59
2.6.1　装箱的过程 59
2.6.2　拆箱的过程 60
2.6.3　如何避免拆箱和装箱 60
2.7　本章小结 61
2.8　思考题 61
第3章　C#类型基础（下） 62
3.1　类型的非方法成员 62
3.1.1　常量 62
3.1.2　字段 63
3.1.3　无参属性 64
3.1.4　有参属性 66
3.1.5　属性的意义 67
3.2　类型的构造函数和析构函数 67
3.2.1　静态类 67
3.2.2　实例构造函数（引用类型） 68
3.2.3　实例构造函数（值类型） 69
3.2.4　静态构造函数 69
3.2.5　构造函数的执行顺序 70
3.2.6　析构函数 71
3.3　类型的普通方法成员 72
3.3.1　方法表 73
3.3.2　使用WinDbg探查方法表 73
3.3.3　方法槽表与方法描述表在JIT前后的变化 75
3.3.4　方法调用 77
3.3.5　方法参数的按值传递和按引用传递 80
3.4　类型转换 82
3.4.1　将一个对象转换为它的基类型 83
3.4.2　将一个对象转换为它的派生类型 84
3.4.3　基元类型的类型转换 84
3.4.4　自定义类型转换 84
3.5　System.Object类型的主要方法 85
3.6　本章小结 90
3.7　思考题 91
第4章　C#和面向对象 92
4.1　面向对象程序设计 92
4.2　继承 93
4.2.1　方法表与继承 94
4.2.2　再论Call与Callvirt 94
4.2.3　IL中修饰方法的关键字 95
4.2.4　方法的重载、重写和隐藏 96
4.2.5　值类型的方法调用 100
4.3　接口和多态 101
4.3.1　抽象类与Is A关系 102
4.3.2　接口与Has A关系 102
4.3.3　显式接口实现 103
4.3.4　显式接口实现与泛型接口 104
4.3.5　抽象类VS接口 105
4.3.6　接口不继承自Object 106
4.3.7　接口方法分派 106
4.4　面向对象编程五大原则（SOLID） 106
4.4.1　单一职责原则 107
4.4.2　开闭原则 107
4.4.3　里氏代换原则 111
4.4.4　接口隔离原则 111
4.4.5　依赖倒转原则 112
4.5　本章小结 112
4.6　思考题 113
第5章　字符串 114
5.1　字符 114
5.2　字符串的特性 115
5.2.1　字符串与普通的引用类型相比 116
5.2.2　IL中创建字符串 116
5.2.3　字符串的不变性 117
5.2.4　通过成员来证明不变性 118
5.2.5　为什么要这么设计 119
5.3　字符串驻留 119
5.4　字符串的相加 121
5.5　不变性只是针对托管代码 124
5.6　本章小结 125
5.7　思考题 125
第6章　垃圾回收 126
6.1　垃圾回收的概念 127
6.1.1　GC堆的构造 127
6.1.2　识别垃圾 128
6.1.3　压缩 136
6.1.4　C#的GC规则总结 136
6.2　垃圾回收策略 136
6.2.1　Dispose方法和IDisposible接口 136
6.2.2　析构函数（终结器） 137
6.2.3　如何回收托管资源 140
6.2.4　如何回收非托管资源 142
6.2.5　using关键字 143
6.2.6　总结：怎样实现垃圾回收策略 144
6.3　GC的工作模式 145
6.3.1　工作站模式 145
6.3.2　服务器模式 146
6.4　大对象 146
6.5　本章小结 147
6.6　思考题 147
第7章　异常与异常处理 148
7.1　C#的异常处理 149
7.1.1　try 149
7.1.2　catch 149
7.1.3　finally 150
7.1.4　结构化异常处理 152
7.1.5　throw和throw ex 153
7.2　IL中的异常处理机制 155
7.3　开发中的异常处理 159
7.3.1　提高程序的健壮性 159
7.3.2　使用.NET自带的日志类型 159
7.4　本章小结 163
7.5　思考题 163
第二部分　C#特性
第8章　委托和事件 166
8.1　委托 166
8.1.1　委托初探 166
8.1.2　使用委托达到代码复用的目的 168
8.1.3　委托的协变和逆变 171
8.1.4　委托的本质 171
8.1.5　委托链与多路广播 174
8.1.6　委托的异步调用 176
8.2　事件 176
8.2.1　事件初探 177
8.2.2　事件的本质 180
8.2.3　Winform中的经典事件：单击按钮 182
8.2.4　Windows消息机制简介 183
8.2.5　观察者模式 185
8.3　本章小结 189
8.4　思考题 189
第9章　泛型 190
9.1　泛型方法 190
9.1.1　类型安全与代码爆炸 191
9.1.2　泛型类型的静态成员 193
9.1.3　泛型与继承 194
9.1.4　泛型约束 194
9.1.5　泛型委托 195
9.1.6　使用泛型委托达到代码复用的目的 196
9.2　可空类型 197
9.3　协变和逆变 200
9.3.1　可变性 200
9.3.2　通过反射调用泛型方法 207
9.4　本章小结 208
9.5　思考题 208
第10章　反射 209
10.1　初识反射 209
10.1.1　获得类型的基本信息 210
10.1.2　获得类型成员和方法调用 211
10.1.3　加载程序集（晚期绑定） 215
10.1.4　反射与泛型 216
10.2　反射的应用场景 218
10.3　反射的性能问题 218
10.3.1　方法反射调用有多慢 218
10.3.2　通过其他方法优化反射调用方式 220
10.3.3　反射优化的性能比较 225
10.4　反射的应用：一个简单的ORM 225
10.4.1　通过反射和特性建立表格和实体的联系 226
10.4.2　为实体增加主键 227
10.4.3　建立本地数据库 228
10.4.4　建立表格 228
10.4.5　删除表格 231
10.4.6　为表格插入数据 231
10.4.7　选择数据 233
10.4.8　多表联查怎么办 234
10.4.9　优化ORM：使用委托来获得值 235
10.4.10　完整的实现代码 235
10.4.11　小结 242
10.5　本章小结 242
10.6　思考题 243
第11章　C#的数据结构 244
11.1　IEnumerable 244
11.1.1　迭代器模式 244
11.1.2　什么是IEnumerable 245
11.1.3　实现一个继承IEnumerable的类型 245
11.1.4　yield的延迟执行特性 256
11.1.5　IEnumerable是一个可枚举序列，但不是容器 257
11.1.6　在迭代的过程中改变集合的状态 259
11.1.7　IEnumerable的缺点和总结 259
11.2　IEnumerable的派生类 260
11.2.1　Array 260
11.2.2　ArrayList 261
11.2.3　IDictionary 262
11.3　IEnumerable的派生类 272
11.3.1　IList 272
11.3.2　LinkedList 272
11.3.3　Queue 281
11.3.4　Stack 283
11.3.5　IDictionary 284
11.3.6　ISet 287
11.4　常用数据结构特征以及操作时间复杂度 288
11.5　如何选择数据结构 289
11.6　本章小结 289
11.7　思考题 290
第12章　LINQ的准备工作 291
12.1　匿名函数、捕获变量与闭包 291
12.1.1　匿名函数 291
12.1.2　演示捕获变量 293
12.1.3　闭包 300
12.2　LINQ的准备工作 301
12.2.1　自动实现的属性 302
12.2.2　隐式类型的局部变量 302
12.2.3　匿名类型 303
12.2.4　扩展方法 305
12.3　Lambda表达式和表达式树 306
12.3.1　从匿名函数到Lambda表达式 306
12.3.2　表达式简介 308
12.3.3　构建简单的表达式树 309
12.3.4　表达式树与反射 311
12.4　本章小结 315
12.5　思考题 315
第13章　LINQ to Object 316
13.1　LINQPad 316
13.2　Enumerable是什么 318
13.3　使用Northwind数据源演示查询操作 318
13.4　投影操作符与过滤操作符 318
13.4.1　Select整个表 318
13.4.2　Select部分列 319
13.4.3　Select结合Lambda表达式 320
13.4.4　使用where进行过滤 320
13.4.5　SelectMany 321
13.4.6　Distinct 324
13.5　排序操作符 325
13.6　分组操作符 325
13.7　通过Let声明局部变量 328
13.8　连接操作符 329
13.8.1　使用join子句的内连接 330
13.8.2　使用join into子句进行外连接 330
13.9　其他常用的操作符 331
13.10　延迟执行 333
13.11　查询表达式和方法语法 335
13.12　本章小结 336
13.13　思考题 336
第14章　LINQ to SQL 337
14.1　IQueryable 337
14.2　IQueryable与 IEnumerable的异同 338
14.3　数据库操作 339
14.3.1　弱类型实体集 339
14.3.2　Entity Framework 340
14.3.3　Repository模式 342
14.4　使用LINQ to Entity Framework 342
14.4.1　Database First 342
14.4.2　Model First 346
14.4.3　Code First 347
14.5　表达式树转化为SQL 348
14.5.1　准备工作 349
14.5.2　实现IQueryable 351
14.5.3　实现IQueryProvider 352
14.5.4　测试IQueryable的运行流程 354
14.5.5　表达式查看器 355
14.5.6　第一步：解析Where表达式 355
14.5.7　第二步：解析Where Lambda表达式 357
14.5.8　表达式树转化为SQL的总结 360
14.6　LINQ与EF的性能问题 361
14.6.1　避免Select N+1 361
14.6.2　避免重复枚举同一序列 362
14.6.3　避免毫无必要地枚举整个序列 363
14.6.4　Entity Framework的预热 364
14.6.5　AsNoTracking方法 365
14.6.6　简化传入字符串排序的代码 365
14.7　LINQ to Rx 370
14.7.1　事件流序列操作LINQ化 371
14.7.2　事件的限流 372
14.7.3　本质：推模型和拉模型 373
14.8　本章小结 373
14.9　思考题 374
第15章　动态语言运行时 375
15.1　dynamic关键字简介 375
15.1.1　动态类型简化晚期绑定 376
15.1.2　动态类型简化COM互操作 378
15.1.3　动态类型相比泛型更加灵活 379
15.1.4　使用ExpandoObject创建动态类型 380
15.1.5　动态类型的好处 381
15.1.6　动态类型的限制 381
15.2　动态类型的原理 382
15.2.1　调用点 382
15.2.2　使用C# object类型模拟动态类型 383
15.2.3　建立调用点 384
15.2.4　初始化调用点 384
15.2.5　使用调用点的目标 385
15.2.6　DLR的缓存策略 386
15.3　本章小结 387
15.4　思考题 387
第16章　C# 6与C# 7的重要特性 388
16.1　C# 6的主要特性 388
16.1.1　自动属性的再次进化 388
16.1.2　简易函数表达式写法 390
16.1.3　字符串插值 392
16.1.4　使用static using调用静态类方法 392
16.1.5　判定null的简写操作符. 393
16.1.6　异常过滤 394
16.1.7　nameof运算符 394
16.2　C# 7的主要特性 395
16.2.1　数字字面量 395
16.2.2　改进的out关键字 396
16.2.3　模式匹配 397
16.2.4　C# 7的值类型元组 399
16.2.5　解构 402
16.2.6　局部函数 405
16.2.7　引用返回值和引用局部变量 410
16.2.8　更多的表达式体成员 414
16.2.9　在更多的地方抛出异常 415
16.2.10　具有值类型的引用语义 415
16.3　C# 8前瞻 416
16.4　本章小结 417
16.5　思考题 417
第三部分　多线程和异步
第17章　多线程概念 420
17.1　进程和线程 420
17.1.1　操作系统简单发展史 420
17.1.2　进程 421
17.1.3　进程调度 424
17.1.4　进程的上下文切换 424
17.1.5　线程 425
17.1.6　单核CPU多线程是否能够提高性能 428
17.2　.NET中的进程与应用程序域 428
17.2.1　.NET中的进程（托管进程） 428
17.2.2　进程间通信 428
17.2.3　使用剪贴板实现进程间通信 429
17.2.4　应用程序域 431
17.3　.NET中的线程（托管线程）与Thread类的基本使用 432
17.3.1　创建线程 433
17.3.2　线程命名 433
17.3.3　前台线程和后台线程 434
17.3.4　线程的状态 435
17.3.5　向线程传递数据 437
17.3.6　异常处理 438
17.4　线程池 439
17.4.1　线程池是如何管理线程的 439
17.4.2　线程池的线程调度策略 440
17.4.3　使用线程池：显式操作 441
17.4.4　使用线程池：异步委托 442
17.4.5　使用线程池：通过任务 442
17.5　线程局部存储区（TLS） 443
17.5.1　使用[ThreadStatic]特性 443
17.5.2　使用Thread类上的两个方法：GetData和SetData 444
17.5.3　使用ThreadLocal 445
17.6　本章小结 446
17.7　思考题 447
第18章　多线程同步 448
18.1　多线程同步的概念 448
18.2　锁：基元构造 455
18.3　用户模式构造 456
18.3.1　同步问题的提出 456
18.3.2　JIT优化、有序性和指令重排 457
18.3.3　C#的内存模型 459
18.3.4　可见性、有序性、内存栅栏与volatile关键字 460
18.3.5　避免使用volatile 464
18.3.6　互锁构造 465
18.3.7　Interlocked Anything模式 466
18.3.8　使用用户模式构造的例子 467
18.3.9　实现自旋锁 468
18.3.10　SpinLock 469
18.4　内核模式构造 470
18.4.1　通过WaitHandle操作内核对象 471
18.4.2　事件构造 472
18.4.3　信号量构造 477
18.4.4　使用信号量实现锁 478
18.4.5　互斥量构造 478
18.4.6　基元构造锁总结 479
18.5　锁：混合构造 480
18.5.1　一个简单的混合锁 481
18.5.2　优化DIY混合锁：使锁支持递归和自旋 482
18.5.3　最常用的锁：Monitor的工作原理 484
18.5.4　Monitor的递归调用 485
18.5.5　如何选择同步对象 486
18.6　.NET 4中新增的轻量级同步工具 488
18.6.1　ManualResetEventSlim和SemaphoreSlim类 489
18.6.2　ReaderWriterLockSlim类 489
18.7　这么多锁：总结 491
18.8　线程安全的集合类 491
18.9　本章小结 494
18.10　思考题 494
第19章　.NET 4之前的异步编程 495
19.1　基本概念 495
19.2　使用System.Threading进行异步编程 497
19.2.1　耗时任务 497
19.2.2　最简单的异步编程 497
19.2.3　获得执行结果 498
19.2.4　实现回调函数获得执行结果 499
19.2.5　线程统一取消模型 500
19.2.6　总结 504
19.3　基于委托的异步编程模型 505
19.3.1　APM的设计规范 505
19.3.2　获得异步委托的执行结果 506
19.3.3　System.IAsyncResult接口 507
19.3.4　通过回调的方式获得异步委托的执行结果 508
19.3.5　使用线程统一取消模型进行取消 509
19.3.6　捕获异步编程的异常 511
19.3.7　GUI的线程处理模型 512
19.3.8　GUI中使用委托进行异步—Control.Begin-Invoke原理 513
19.3.9　GUI中使用委托进行异步—WinForm程序示例 515
19.3.10　总结 517
19.4　基于事件的异步编程模式 518
19.4.1　EAP的设计规范 518
19.4.2　BackgroundWorker类简介 519
19.4.3　GUI中使用EAP进行异步—WPF程序示例 521
19.4.4　总结 525
19.5　我们需要这么多异步编程的方法吗 525
19.6　本章小结 525
19.7　思考题 526
第20章　任务并行库 527
20.1　任务并行库 527
20.2　使用任务进行异步编程 528
20.2.1　新建任务 528
20.2.2　任务的状态 529
20.2.3　任务调度器 530
20.2.4　任务工厂 531
20.3　获得任务的执行结果 532
20.3.1　等待任务完成 532
20.3.2　任务连接作为回调函数 533
20.3.3　使用过去的方式 539
20.4　任务的异常处理 539
20.4.1　父子任务中的异常处理（附加子任务） 541
20.4.2　父子任务中的异常处理（分离子任务） 541
20.5　任务的取消 544
20.5.1　直接退出任务 544
20.5.2　利用ThrowIfCancellation-Requested方法545
20.5.3　任务取消的异常处理 545
20.5.4　任务异常处理：总结 548
20.6　在WPF中使用任务 549
20.7　并行编程与PLINQ 552
20.8　Parallel类 553
20.8.1　Parallel.Invoke与任务并行 554
20.8.2　Parallel.For/ForEach与数据并行 555
20.8.3　收集任务的执行结果 558
20.8.4　指定最大并行度 558
20.8.5　在Parallel类中捕捉异常 559
20.8.6　使用ParallelOption取消并行任务 560
20.8.7　使用ParallelLoopState退出For/ForEach循环 562
20.8.8　Parallel方法的取消与异常处理总结 563
20.9　PLINQ 564
20.9.1　指定执行模式 566
20.9.2　指定并行度 567
20.9.3　PLINQ与排序 567
20.9.4　PLINQ的数据分区策略 568
20.9.5　PLINQ的输出端与结果收集策略 571
20.9.6　使用Aggregate的并行版本进行计算 572
20.9.7　取消PLINQ查询 572
20.9.8　在PLINQ中捕捉异常 573
20.9.9　总结：是否需要使用PLINQ 574
20.10　Lazy和延迟初始化 574
20.11　本章小结 576
20.12　思考题 576
第21章　.NET 4.5异步编程实例 577
21.1　初识async/await 577
21.1.1　异步方法的执行流程 579
21.1.2　异步方法的异常处理 582
21.1.3　异步方法的取消 584
21.1.4　调用方法获得结果的几种方式 585
21.1.5　async和await总结 587
21.2　了解async/await的原理 588
21.2.1　示例程序 588
21.2.2　使用ILSpy反编译 589
21.2.3　状态机结构 589
21.2.4　骨架方法 594
21.2.5　异常处理 595
21.3　GUI：使用async和await关键字进行异步操作 595
21.3.1　异步操作的基本模型 596
21.3.2　使用WhenAll等待一组任务完成 597
21.3.3　使用WhenAny等待任意一个任务完成 598
21.3.4　任务完成时的处理 599
21.4　可等待模式 600
21.4.1　定义 600
21.4.2　await anything 601
21.5　本章小结 603
21.6　思考题 604
后记 605
附录　程序员面试流程概览 606

.　　图3.NET程序开发必要技能地图—C#相关
　　对于上面这些问题，本书会一一进行讨论。上面这些知识点的掌握，是在简历上写下“熟悉C#”（注意，这里我没有使用“精通”二字）的前提。这部分知识也是面试时的重中之重，面试官筛人的利器。如果这些知识都不是很清楚，那么“熟悉C#”也就成了一句笑话。
　　设计与架构相关
　　设计与架构相关的内容如图4所示，其重要性仅次于主语言，因为这个技能严重影响代码质量。这块内容的学习和理解绝非一日之功，对它进行“临时抱佛脚”基本是不可能的，通过考察面试者对设计模式、面向对象的理解，基本可以准确地将面试者归到高手、中等和初学者这三类中。当然，如果岗位本身比较初级，那么这方面的要求将会相应降低。
　　因为C#是一个面向对象的编程语言，所以，面向对象成为面试考察的重点内容。经典的设计模式就是灵活运用面向对象的结果。常用的知识点包括：
　　面向对象设计五大原则。光背书没用，一定要用过（在项目中用或者自己用）才能有自己的心得体会。
　　常用设计模式，包括单例模式、策略模式、观察者模式、工厂方法模式等，及其UML类图。
　　依赖注入的概念，以及依赖注入的工具。
　　对所有设计模式的全面讨论超出了本书的范围。本书第4章“C#和面向对象”会简单介绍面向对象设计五大原则。另外，本书会在讲述C#语言特性时穿插一些常用设计模式，例如事件和观察者模式、开闭原则和工厂方法模式等。
　　对设计模式的学习，可以参考著名的《设计模式：可复用面向对象软件的基础》这本书，它是设计模式的开山之作。另外，程杰的《大话设计模式》这本书，也以生动有趣的方式讲述了各种设计模式的原理和用法。然而，最重要的还是自己亲自操作实践，以写代码的方式体会设计模式的好处。
　　岗位相关
　　如果用人单位招的是ASP.NET程序员，那么肯定得了解ASP.NET生命周期、路由、前后端传值、MVC，以及至少一门前端语言等。如果招的是后端，可能会问一些关于Web服务、WebAPI的知识。专门负责写WPF应用的岗位，可能会在线程上大做文章。这些知识都是.NET框架类库的一部分。本书不会讨论具体某个框架类库的使用，.NET平台各大主流框架类库都有众多相关书籍供参考。
　　当然，框架类库的基础知识点也很重要。例如对WPF，如果你不知道如何禁止用户更改窗口的大小，那没什么关系，上网一查即可；但如果你不清楚长任务时如何保证界面良好的响应，工作线程如何更改UI线程控件的值，那么你编写出来的WPF应用一定会让用户怨声载道。
　　有些岗位还需要应聘者清楚分布式、脚本语言、Linux环境、缓存、消息队列、高级算法、大数据应用等相关知识。对这些知识的掌握和理解，一方面需要看书，另一方面也要结合相关项目经验。岗位相关的知识点五花八门，因岗而异。
　　数据库相关
　　确实有一些开发者不需要和数据库打交道，不过，大部分岗位都要求对数据库操作有一定了解。数据库方面的技能如图5所示，如果一个岗位要求熟悉数据库，那么面试官期待的将是：
　　使用主语言访问数据库并熟练掌握增删改查操作。对于C#做主语言的情况，可以使用非ORM（ADO.NET）或ORM（Entity Framework）两种工具。你了解你目前所使用的ORM吗？
　　基本的SQL书写。DBMS常用对象及工具，例如表、视图、存储过程等。
　　数据库基础知识，例如什么是范式，为什么数据库要遵循范式，不遵循范式的数据库会产生什么问题，什么是索引（聚集索引和非聚集索引），索引的利弊等。
　　什么是事务，为什么需要事务，没有事务会怎么样，解释事务隔离层级。
　　上面说的都是关系型数据库中最重要的知识点，有些岗位还需要应聘者懂得非关系型数据库、数据仓库等。而至于数据库的一些其他知识，例如存储过程、触发器、性能优化等，限于篇幅，这里就不详细展开了，应聘者可以根据岗位需求自行准备。《数据库系统概念》是一本非常经典的大学教材及优秀参考书。
　　线程相关
　　很多复杂的应用都会出现多线程的身影，线程相关的技能如图6所示。Windows操作系统赋予了我们使用线程的能力，我们可以利用多线程改善程序的性能。对这一块知识，很多初级开发者都不清楚，可能是由于没有机会写一个需要多线程的应用。关于多线程的材料较少，而且多为英文，也是初级开发者对于线程不清楚的另一个原因。
　　图6.NET程序开发必要技能地图—线程相关
　　但是，大型应用，或者对性能要求很高的应用，多线程则无处不在。.NET本身也提供了非常丰富的线程管理类库。本书第17～21章试图对这一块内容进行较为全面的讲解。
　　语言相关
　　这里的语言相关是指使用英语的能力。具体来说，包括阅读英文文档、英文邮件写作，甚至使用英语和他人进行沟通的能力。对于外企来说，这块非常重要，而非外企则相对不那么重要，但由于目前大部分较为权威的文档和资料仍然是英文的，而且缺乏翻译，所以开发者还是需要把自己的英语水平提升，能够无障碍地阅读英文技术文档。
　　这一块的学习只能通过日积月累，别无捷径。不过，我不推荐大家马上拿来一本四六级甚至托福单词去背，因为，其中大部分单词在实际开发中都遇不到，而真正需要知道的单词（例如，delegate委托，interface接口等），要么不在词汇表里，要么根本不是这个意思，而你把abandon（四级的第一个单词）背得再熟，平时也基本看不见它。更快捷的方法是阅读MSDN文档，并把不会的单词记录下来。
　　加分技能
　　软件工程和项目经验相关
　　虽然也有单枪匹马搞定项目的例子，但那通常出现在“远古时代”，现在的软件开发项目越来越复杂，常常需要多个人组成团队一起合作。团队会有专门的项目经理负责需求的整理（也可能没有，如开发者自己兼职项目经理），制定开发进度，开发者同心协力，从小目标开始，分而治之，最终完成项目。面试官（可能是开发者，可能是管理开发者的团队领导），不仅仅关心一个团队新人是否有能力完成领导交给他的任务，也会关心这个新人是否可以和现有人员通力合作。面试官可能会问以下问题，并根据你的回答默默思考你和新团队的契合程度：
　　项目经验。你之前做过什么，最得意的项目是什么，你在其中处于什么角色，解决了什么问题。
　　你之前的项目是瀑布开发模型还是敏捷，你更喜欢哪种，敏捷有什么优点和缺点。
　　你之前公司的代码是如何实现版本控制的。
　　你对单元测试有什么认识，是否写过单元测试代码。
　　如果面试者对这一块很不清楚，或者，面试者之前完全没有用过相关的工具（代码控制、测试等），面试官可能会担心这位面试者写出来的代码质量不高。不过，如果岗位没有对这一块具体写出要求，那么这部分是锦上添花，会的话加分，不会也“罪不至死”。
　　其他个人经历
　　这部分主要包括个人网站、社区贡献（如写书、翻译、MVP、论坛回答问题等）、开源项目，甚至个人出版物等。随着网络的开放，开源运动的兴起，越来越多的开发者愿意分享自己的知识和代码到社区，也对其他开发者的批评和指正报以积极的回应。
　　由于大部分人都没有什么社区贡献，因此，在社区积极热心提供知识的那些开发者就很容易脱颖而出。参与社区的活动会扩大自己的人脉，从而对找工作有着积极的作用。而且，对社区的贡献也体现出一个人在工作之余，仍然对技术有着浓厚的兴趣，并愿意将自己的心得体会分享给他人。
　　高级技能
　　除了上面列出的技能外，如果应聘的职级较高，那么还可能会有属于高级开发人员的一些必备技术型技能。这些技能不是一项特定的技术，而是各项技能的综合，用于解决一些特定的问题。
　　例如，大部分大型IT公司都拥有一个自己的门户网站，它的访问量是十分巨大的，因此，大型IT公司的高级开发人员必须熟悉如何让系统在超高并发下保持稳定，找出系统性能的瓶颈，然后对其进行优化。对这个问题的解答，并不限于一门语言或一种工具，而涉及方方面面的知识，这些知识的积累通常需要完整经历一个大型项目，并且该项目要足够大，这就限定了先决条件—小公司基本上是无缘大型项目的。具备高级技能的开发者在就业市场上屈指可数。
　　.NET程序开发进阶之路
　　在下面的讨论中，我简单地将.NET程序员分为初学者、中级和高级开发人员三类。
　　初学者
　　刚工作几年，也许用C# + ASP.NET写过一个订单管理系统，该系统可能包括若干页面、一堆表格，本质是数据库CRUD。这个系统东西虽小，但五脏俱全。有些开发者的系统写出来是这样的：
　　没有合适的架构，控制器有时直接获取数据，有时又通过其他函数获取。
　　没有任何测试保护。
　　前端后端代码一团糟，毫无代码质量意识，例如，长达数百行的函数、超多层if嵌套、命名诡异等。
　　不留注释。
　　懒人异常处理法：catch(Exception ex){/*…*/}。
　　类似的问题还有很多，而写出这种系统的开发者无疑属于初学者（即使他做了很多项目）。初学者还有一个典型的特性，就是完全看不懂技术专家在写什么。例如，技术专家写了一篇优化反射性能的文章，初学者却连什么是反射、委托、IL都不知道。
　　当初学者去了几间比较大型的公司应聘之后，发现他的订单管理系统并未受到面试官的青睐，而面试官提出的问题大部分都是“C#相关”中的知识点，而他一问三不知。受到若干次挫折之后，有些初学者选择开始从头看书，好好学习，有些初学者则抱怨大公司总是“考背书”。
　　计算机领域中，开发者人才济济，逆水行舟，不进则退。如果初学者永远不进步，迟早会被公司和社会淘汰，会有新人来顶替你。因此，很多初学者都选择在工作之余读书进修，攻克自己还不清楚的技术知识点。
　　中级开发人员
　　如果你已经清楚了“C#相关”中的绝大部分知识（当然面试官还是很有可能问倒你的），对答如流，并且熟悉基本的设计与架构知识，你就可以算是中级开发人员了。中级开发人员的ASP.NET订单管理系统就比初级人员写出来的强多了，例如：
　　前后端代码质量脱胎换骨，通常都可以通过所谓的“醉酒测试”（即给一个喝醉了的开发者来看，他也能看得懂）。
　　有明确清晰的架构，每层只做每层该做的事。
　　基本符合SOLID。
　　如果使用ORM更合适，会使用一款ORM。
　　努力优化自己的代码。
　　努力进行单元测试和集成测试。
　　在异常处理和日志记录上下了很多工夫。
　　一个称职的ASP.NET方向的中级开发人员应该可以独立完成该系统，或者指导若干初学者通力完成。不过，当该系统规模越来越大，访问量越来越多时，中级开发人员现有的知识储备已经不足以保持系统的稳定运行了。例如，需要引入数据库的读写分离、服务器的负载均衡等，这些都超出了.NET和C#的范围，而需要学习更多知识。此时，他们就会求助于高级开发人员。
　　高级开发人员
　　高级开发人员需要掌握的知识早已超出了本书的范围。高级开发人员不仅熟悉本书提到的大部分知识，另外在性能优化等其他专题上有自己的心得。他们可独自冲锋陷阵，解决初级和中级开发者解决不了的问题，还可以指挥开发团队通力合作，完成大型项目。系统性能变差但不知道原因，出现bug解决不了的时候，大家一筹莫展，齐刷刷地把头望向高手：怎么办？名副其实的高级开发人员，通常都可以完美地解决问题。
　　本书的结构
　　本书分为三部分：
　　基础知识（第1～7章）：包括.NET的相关知识、C#的类型基础和内存分配、继承和多态、字符串相关知识、垃圾收集、异常处理等。
　　C#特性（第8～16章）：从委托事件开始逐一介绍C#各版本的主要特性。
　　多线程和异步（第17～21章）：介绍多线程的基本概念、线程同步工具以及不同C#版本的异步编程模型。
　　本书参考的主要资料
　　下面这部分内容是本书主要的参考资料简介，有的偏理论，有的偏实用。
　　《CLR via C#第4版》Jeffrey Richter
　　这本书实在太重要了，太有名了。实际上，它几乎出现在任何一本C#书籍的参考资料中。该书虽然现在看来已经有点“过时”了，但它对CLR的讲解十分透彻，仍有价值。很多国内作者写的C#书籍，都或多或少地受了这本书的影响。
　　该书虽然很厚，但结构十分清晰，分为五大部分：
　　CLR基础，讲程序集的结构和部署、IL、JIT、类型系统。第1章很重要，必须好好看。
　　设计类型，该部分遍览了一个类型可以拥有的所有成员，所有章节都很重要，第12章“泛型”尤其重要。
　　基本类型，第13、14、16、17、19章很重要。
　　核心机制，主要包括异常处理、GC、应用程序域、反射和序列化。
　　线程处理，作为Windows操作系统的大师，作者对线程的理解非常深入。第26章主要是概念，第27～30章全是多线程，通读、阅读这部分对多线程的理解帮助极大。
　　这本书由于成书较早，因此缺失了对C#一些较新版本功能的介绍，例如LINQ等。
　　《深入理解C#》Jon Skeet
　　这本书相比上一本不那么“底层”，不过，它的阅读难度也不小。对于更喜欢特性而非原理的读者，可以通读一遍此书，它按照演进顺序讲述了C# 1～5的所有特性，对LINQ、异步的讲解既实用又涉及原理。这本书所有章节都很重要。
　　《.NET设计规范：约定、惯用法与模式》Krzysztof Cwalina
　　在争论应该是抽象类还是接口，应该是类还是结构时，我们其实看看这本书就够了，它早就给了我们一大堆最佳实践。不知道怎么书写异常处理？看看该书的第7章吧。这本书实际上就是一个代码规范集合。
　　这本书适合在需要的时候随时查阅。以上三本书相辅相成，包括了一个中级开发者需要掌握的所有语言相关技能。实际上，即使只理解一半也已经足够好了。
　　《Pro .NET Performance》Sasha Goldsftein
　　这本书以一个独特的视角—性能作为切入点，讲述了.NET程序和类型在性能这方面的体现。该书的前两章主要讨论了性能测试的衡量方法和工具，第3章深入介绍类型系统，第4章详细讲述了GC，这两章值得细读。这本书目前只有英文版，阅读难度很大。
　　《.NET本质论（第一卷）：公共语言运行时》Don Box
　　这本书实际上就是在讲CLR，也是据我所知对CLR的探讨最底层、最深入的一本。该书的作者同时也是COM专家，因此，对于CLR这个更好的COM来说，他必然驾轻就熟。我最喜欢这本书的第6章，作者使用了一章的篇幅讨论了方法调用。该书过于底层，成书年代也很早，读起来可能有些脱离实际的感觉。
　　《NET 4.0面向对象编程漫谈：基础篇》金旭亮
　　金旭亮老师的这本书（以及下一本书）以生动有趣的笔触讲解了.NET的方方面面。我个人非常喜欢这本书。如果你觉得《CLR via C#》太枯燥，行文方式又过于“老外”，看不下去，可以先看这本。这本书虽然没有《CLR via C#》那么深，但对于底层也有颇多涉及，它和很多粗制滥造的“拖控件教程”有着本质的不同。
　　《NET 4.0面向对象编程漫谈应用篇》金旭亮
　　作者在该书中着重分析了进程和线程以及在C#中的实际应用，这是多线程方面为数不多的好资料。
　　《你必须知道的.NET（第2版）》王涛
　　这本书的编排顺序十分独特，它的视角是完全面向对象的，并且将.NET各个知识点以逐个对比的方式呈现在读者面前。第一次阅读时，可能会觉得不太适应。这本书有一定深度，而且作者行文比较幽默，因此读起来也不是很枯燥。这本书有很多SOLID和设计模式方面的内容，对开发者不无裨益。
　　《Threading in C#》
　　这本书（以网页形式在网上公开）提供了另外学习C#多线程的资料，目前已经有翻译版本https://blog.gkarch.com/threading/part1.html。该书对.NET提供的各种各样的锁都有所涉及，可以和《CLR via C#》最后四章一起看。
　　本书的开发环境
　　本书使用Visual Studio 2017 Community + Windows 7进行开发。Visual Studio 2017 Community是完全免费的，你可以在https://www.visualstudio.com/downloads/下载它。
　　代码下载与联系作者
　　本书的代码可以从下面的链接获得：https://github.com/s055523/CodeForCSharpBook。
　　由于笔者水平有限，书中或代码中难免会出现一些错误。如果你在阅读时发现了任何问题，请务必反馈给我。可以通过我的博客地址：http://www.cnblogs.com/haoyifei/或邮箱s055523@gmail.com联系我。
　　致谢
　　首先要感谢我的妻子王妍在我写书时的全力支持和理解。没有她在背后的付出，这本书是不可能很顺利完成的。
　　我还要感谢李志，王清培、凌光、张子阳，他们为本书的写作提出了很多宝贵的建议，并撰写了推荐语。最后，感谢机械工业出版社责任编辑吴怡女士，她丰富的出版经验与认真的工作态度，是这本书得以出版的前提。