深入解析C#（第4版） 下载 pdf 百度网盘 epub 免费 2025 电子书 mobi 在线

C#语言简洁优雅，精妙强大，是当今编程语言的集大成者，功能不断推陈出新，受到众多开发人员的推崇。本书是C#领域不可多得的经典著作，新版重磅升级，不仅重新组织了内容，还全面更新并细致剖析了C# 6和C# 7的新增特性，为读者奉上知识盛宴。作者在详尽展示C#各个知识点的同时，注重从现象中挖掘本质，解读语言背后的设计思想，深入探究了C#的核心概念和经典特性，并将这些特性融入代码示例，帮助读者顺畅使用C#，享受使用C#编程的乐趣。

前言

致谢

关于本书

关于作者

关于封面插图

第一部分 C#背景介绍

第1章 大浪淘沙 2

1.1 一门与时俱进的语言 2

1.1.1 类型系统——全能型助手 3

1.1.2 代码更简洁 4

1.1.3 使用LINQ简化数据访问 8

1.1.4 异步 8

1.1.5 编码效率与执行效率之间的取舍 9

1.1.6 快速迭代：使用小版本号 10

1.2 一个与时俱进的平台 11

1.3 一个与时俱进的社区 12

1.4 一本与时俱进的好书 13

1.4.1 内容详略得当 13

1.4.2 使用Noda Time作为示例 14

1.4.3 术语选择 14

1.5 小结 15

第二部分 从C# 2到C#5

第2章 C# 2 18

2.1 泛型 18

2.1.1 示例：泛型诞生前的集合 19

2.1.2 泛型降临 21

2.1.3 泛型的适用范围 25

2.1.4 方法类型实参的类型推断 26

2.1.5 类型约束 28

2.1.6 default运算符和typeof运算符 30

2.1.7 泛型类型初始化与状态 32

2.2 可空值类型 34

2.2.1 目标：表达信息的缺失 34

2.2.2 CLR和framework的支持：Nullable结构体 35

2.2.3 语言层面支持 38

2.3 简化委托的创建 43

2.3.1 方法组转换 43

2.3.2 匿名方法 44

2.3.3 委托的兼容性 45

2.4 迭代器 46

2.4.1 迭代器简介 47

2.4.2 延迟执行 48

2.4.3 执行yield语句 49

2.4.4 延迟执行的重要性 50

2.4.5 处理finally块 51

2.4.6 处理finally的重要性 53

2.4.7 迭代器实现机制概览 54

2.5 一些小的特性 58

2.5.1 局部类型 59

2.5.2 静态类 60

2.5.3 属性的getter/setter访问分离 61

2.5.4 命名空间别名 61

2.5.5 编译指令 63

2.5.6 固定大小的缓冲区 64

2.5.7 InternalsVisibleTo 65

2.6 小结 65

第3章 C# 3：LINQ及相关特性 66

3.1 自动实现的属性 66

3.2 隐式类型 67

3.2.1 类型术语 67

3.2.2 隐式类型的局部变量 68

3.2.3 隐式类型的数组 69

3.3 对象和集合的初始化 71

3.3.1 对象初始化器和集合初始化器简介 71

3.3.2 对象初始化器 72

3.3.3 集合初始化器 74

3.3.4 仅用单一表达式就能完成初始化的好处 75

3.4 匿名类型 76

3.4.1 基本语法和行为 76

3.4.2 编译器生成类型 78

3.4.3 匿名类型的局限性 79

3.5 lambda表达式 80

3.5.1 lambda表达式语法简介 81

3.5.2 捕获变量 82

3.5.3 表达式树 89

3.6 扩展方法 91

3.6.1 声明扩展方法 91

3.6.2 调用扩展方法 92

3.6.3 扩展方法的链式调用 93

3.7 查询表达式 94

3.7.1 从C#到C#的查询表达式转换 95

3.7.2 范围变量和隐形标识符 95

3.7.3 选择使用哪种LINQ语法 96

3.8 终极形态：LINQ 97

3.9 小结 98

第4章 C# 4：互操作性提升 99

4.1 动态类型 99

4.1.1 动态类型介绍 100

4.1.2 超越反射的动态行为 104

4.1.3 动态行为机制速览 108

4.1.4 动态类型的局限与意外 111

4.1.5 动态类型的使用建议 115

4.2 可选形参和命名实参 116

4.2.1 带默认值的形参和带名字的实参 117

4.2.2 如何决定方法调用的含义 118

4.2.3 对版本号的影响 119

4.3 COM互操作性提升 121

4.3.1 链接主互操作程序集 121

4.3.2 COM组件中的可选形参 123

4.3.3 命名索引器 124

4.4 泛型型变 125

4.4.1 泛型型变示例 125

4.4.2 接口和委托声明中的变体语法 126

4.4.3 变体的使用限制 127

4.4.4 泛型型变实例 129

4.5 小结 130

第5章 编写异步代码 131

5.1 异步函数简介 132

5.1.1 异步问题初体验 133

5.1.2 拆分第一个例子 134

5.2 对异步模式的思考 135

5.2.1 关于异步执行本质的思考 136

5.2.2 同步上下文 137

5.2.3 异步方法模型 138

5.3 async方法声明 139

5.3.1 async方法的返回类型 140

5.3.2 async方法的参数 141

5.4 await表达式 141

5.4.1 可等待模式 142

5.4.2 await表达式的限制条件 144

5.5 返回值的封装 145

5.6 异步方法执行流程 146

5.6.1 await的操作对象与时机 146

5.6.2 await表达式的运算 147

5.6.3 可等待模式成员的使用 150

5.6.4 异常拆封 151

5.6.5 完成方法 152

5.7 异步匿名函数 156

5.8 C# 7自定义task类型 157

5.8.1 99.9%的情况：ValueTask 158

5.8.2 剩下0.1%的情况：创建自定义task类型 160

5.9 C# 7.1中的异步Main方法 161

5.10 使用建议 162

5.10.1 使用ConfigureAwait避免上下文捕获（择机使用） 163

5.10.2 启动多个独立task以实现并行 164

5.10.3 避免同步代码和异步代码混用 165

5.10.4 根据需要提供取消机制 165

5.10.5 测试异步模式 165

5.11 小结 166

第6章 异步原理 167

6.1 生成代码的结构 168

6.1.1 桩方法：准备和开始第一步 171

6.1.2 状态机的结构 172

6.1.3 MoveNext()方法（整体介绍） 175

6.1.4 SetStateMachine方法以及状态机的装箱事宜 177

6.2 一个简单的MoveNext()实现 177

6.2.1 一个完整的具体示例 178

6.2.2 MoveNext()方法的通用结构 179

6.2.3 详探await表达式 181

6.3 控制流如何影响MoveNext() 183

6.3.1 await表达式之间的控制流很简单 183

6.3.2 在循环中使用await 184

6.3.3 在try / finally块中使用await表达式 185

6.4 执行上下文和执行流程 188

6.5 再探自定义task类型 189

6.6 小结 190

第7章 C# 5附加特性 191

7.1 在foreach循环中捕获变量 191

7.2 调用方信息attribute 193

7.2.1 基本行为 193

7.2.2 日志 194

7.2.3 简化INotifyPropertyChanged的实现 195

7.2.4 调用方信息attribute的小众使用场景 196

7.2.5 旧版本.NET使用调用方信息attribute 201

7.3 小结 202

第三部分 C# 6

第8章 极简属性和表达式主体成员 204

8.1 属性简史 204

8.2 自动实现属性的升级 206

8.2.1 只读的自动实现属性 206

8.2.2 自动实现属性的初始化 207

8.2.3 结构体中的自动实现属性 208

8.3 表达式主体成员 210

8.3.1 简化只读属性的计算 210

8.3.2 表达式主体方法、索引器和运算符 213

8.3.3 C# 6中表达式主体成员的限制 214

8.3.4 表达式主体成员使用指南 216

8.4 小结 218

第9章 字符串特性 219

9.1 NET中的字符串格式化回顾 219

9.1.1 简单字符串格式化 219

9.1.2 使用格式化字符串来实现自定义格式化 220

9.1.3 属地化 221

9.2 内插字符串字面量介绍 224

9.2.1 简单内插 224

9.2.2 使用内插字符串字面量格式化字符串 225

9.2.3 内插原义字符串字面量 225

9.2.4 编译器对内插字符串字面量的处理（第1部分） 226

9.3 使用FormattableSting实现属地化 227

9.3.1 编译器对内插字符串字面量的处理（第2部分） 228

9.3.2 在特定culture下格式化一个FormattableString 229

9.3.3 FormattableString的其他用途 230

9.3.4 在旧版本.NET中使用FormattableString 233

9.4 使用指南和使用限制 234

9.4.1 适合开发人员和机器，但可能不适合最终用户 235

9.4.2 关于内插字符串字面量的硬性限制 236

9.4.3 何时可以用但不应该用 238

9.5 使用nameof访问标识符 239

9.5.1 nameof的第一个例子 239

9.5.2 nameof的一般用法 241

9.5.3 使用nameof的技巧与陷阱 243

9.6 小结 246

第10章 简洁代码的特性“盛宴” 247

10.1 using static指令 247

10.1.1 引入静态成员 247

10.1.2 using static与扩展方法 250

10.2 对象初始化器和集合初始化器特性增强 252

10.2.1 对象初始化器中的索引器 252

10.2.2 在集合初始化器中使用扩展方法 256

10.2.3 测试代码与产品代码 259

10.3 空值条件运算符 260

10.3.1 简单、安全地解引用 260

10.3.2 关于空值条件运算符的更多细节 261

10.3.3 处理布尔值比较 262

10.3.4 索引器与空值条件运算符 263

10.3.5 使用空值条件运算符提升编程效率 263

10.3.6 空值条件运算符的局限性 265

10.4 异常过滤器 265

10.4.1 异常过滤器的语法和语义 266

10.4.2 重试操作 270

10.4.3 记录日志的“副作用” 272

10.4.4 单个、有针对性的日志过滤器 273

10.4.5 为何不直接抛出异常 273

10.5 小结 274

第四部分 C# 7及其后续版本

第11章 使用元组进行组合 277

11.1 元组介绍 277

11.2 元组字面量和元组类型 278

11.2.1 语法 278

11.2.2 元组字面量推断元素名称（C# 7.1） 280

11.2.3 元组用作变量的容器 281

11.3 元组类型及其转换 285

11.3.1 元组字面量的类型 285

11.3.2 从元组字面量到元组类型的转换 287

11.3.3 元组类型之间的转换 290

11.3.4 类型转换的应用 292

11.3.5 继承时的元素名称检查 292

11.3.6 等价运算符与不等价运算符（C# 7.3） 293

11.4 CLR 中的元组 294

11.4.1 引入System.ValueTuple 294

11.4.2 处理元素名称 294

11.4.3 元组类型转换的实现 296

11.4.4 元组的字符串表示 296

11.4.5 一般等价比较和排序比较 297

11.4.6 结构化等价比较和排序比较 298

11.4.7 独素元组和巨型元组 299

11.4.8 非泛型ValueTuple结构体 300

11.4.9 扩展方法 301

11.5 元组的替代品 301

11.5.1 System.Tuple 301

11.5.2 匿名类型 301

11.5.3 命名类型 302

11.6 元组的使用建议 302

11.6.1 非公共API以及易变的代码 303

11.6.2 局部变量 303

11.6.3 字段 304

11.6.4 元组和动态类型不太搭调 305

11.7 小结 306

第12章 分解与模式匹配 307

12.1 分解元组 307

12.1.1 分解成新变量 308

12.1.2 通过分解操作为已有变量或者属性赋值 310

12.1.3 元组字面量分解的细节 313

12.2 非元组类型的分解操作 314

12.2.1 实例分解方法 314

12.2.2 扩展分解方法与重载 315

12.2.3 编译器对于Deconstruct调用的处理 316

12.3 模式匹配简介 317

12.4 C# 7.0可用的模式 319

12.4.1 常量模式 319

12.4.2 类型模式 320

12.4.3 var模式 323

12.5 模式匹配与is运算符的搭配使用 324

12.6 在switch语句中使用模式 325

12.6.1 哨兵语句 326

12.6.2 case标签中的模式变量的作用域 328

12.6.3 基于模式的switch语句的运算顺序 329

12.7 对模式特性使用的思考 330

12.7.1 发现分解的时机 330

12.7.2 发现模式匹配的使用时机 331

12.8 小结 331

第13章 引用传递提升执行效率 332

13.1 回顾：ref知多少 333

13.2 ref局部变量和ref return 336

13.2.1 ref局部变量 336

13.2.2 ref return 341

13.2.3 条件运算符?:和ref值（C# 7.2） 343

13.2.4 ref readonly（C# 7.2） 343

13.3 in参数（C# 7.2） 345

13.3.1 兼容性考量 346

13.3.2 in参数惊人的不可变性：外部修改 347

13.3.3 使用in参数进行方法重载 348

13.3.4 in参数的使用指导 348

13.4 将结构体声明为只读（C# 7.2） 350

13.4.1 背景：只读变量的隐式复制 350

13.4.2 结构体的只读修饰符 352

13.4.3 XML序列化是隐式读写属性 353

13.5 使用ref参数或者in参数的扩展方法（C# 7.2） 354

13.5.1 在扩展方法中使用ref/in参数来规避复制 354

13.5.2 ref和in扩展方法的使用限制 355

13.6 类ref结构体（C# 7.2） 357

13.6.1 类ref结构体的规则 357

13.6.2 Span和栈内存分配 358

13.6.3 类ref结构体的IL表示 362

13.7 小结 362

第14章 C# 7的代码简洁之道 363

14.1 局部方法 363

14.1.1 局部方法中的变量访问 364

14.1.2 局部方法的实现 367

14.1.3 使用指南 371

14.2 out变量 373

14.2.1 out参数的内联变量声明 374

14.2.2 C# 7.3 关于out变量和模式变量解除的限制 374

14.3 数字字面量的改进 375

14.3.1 二进制整型字面量 375

14.3.2 下划线分隔符 376

14.4 throw表达式 377

14.5 default字面量（C# 7.1） 377

14.6 非尾部命名实参 379

14.7 私有受保护的访问权限(C# 7.2) 380

14.8 C# 7.3的一些小改进 380

14.8.1 泛型类型约束 381

14.8.2 重载决议改进 381

14.8.3 字段的attribute支持自动实现的属性 382

14.9 小结 383

第15章 C# 8及其后续 384

15.1 可空引用类型 384

15.1.1 可空引用类型可以解决什么问题 385

15.1.2 在使用引用类型时改变其含义 385

15.1.3 输入可空引用类型 387

15.1.4 编译时和执行期的可空引用类型 387

15.1.5 damnit运算符或者bang运算符 389

15.1.6 可空引用类型迁移的经验 391

15.1.7 未来的改进 393

15.2 switch表达式 396

15.3 嵌套模式匹配 398

15.3.1 使用模式来匹配属性 398

15.3.2 分解模式 399

15.3.3 忽略模式中的类型 399

15.4 index和range 400

15.4.1 index与range类型和字面量 401

15.4.2 应用index和range 402

15.5 更多异步集成 403

15.5.1 使用await实现异步资源回收 403

15.5.2 使用foreach await的异步迭代 404

15.5.3 异步迭代器 407

15.6 预览版中尚未提供的特性 408

15.6.1 默认接口方法 408

15.6.2 记录类型 409

15.6.3 更多特性 410

15.7 欢迎加入 412

15.8 小结 412

附录 特性与语言版本对照表 413

乔恩•斯基特（Jon Skeet）

谷歌高级软件工程师，微软C# MVP，拥有近20年C#项目开发经验。自2002年来，他一直是C#社区、新闻组、国际会议和Stack Overflow网站中非常活跃的技术专家，回答了数以万计的C#和.NET相关问题，是Stack Overflow上的传奇贡献者。

暂无出版社相关信息，正在全力查找中！

暂无相关书籍摘录，正在全力查找中！

在线阅读地址：深入解析C#（第4版）在线阅读

在线听书地址：深入解析C#（第4版）在线收听

在线购买地址：深入解析C#（第4版）在线购买

当有多个类型参数时，可以用一个适合整个类型含意的单词来分隔它们，例如，我会使用dictionary of string to int来强调映射的部分，而不会使用tuple of string and int。

When there are multiple type parameters, I find it makes sense to separate them with a word appropriate to the meaning of the overall type—so I’d talk about a “dictionary of string to int” in order to emphasize the mapping aspect, but a “tuple of string and int.”

...如果仅仅是接受目标的实现，而不去明确定义从哪里开始，那么一切就没有问题，至少在出错前没什么问题。

如果想弄明白究竟发生了什么才能达到预期效果，事情就变得有点棘手了。既然本书挂着“深入理解”的名头，那么我就假设你想知道这些细节。最终，我保证你在用 await 时会更加自信，并且更加高效。

即便如此，我还是建议各位根据自身情况，在两个不同级别发展阅读异步代码的能力。如果无须理解这里列出的单独步骤，就让它们随风而去好了。你可以像阅读同步代码那样去阅读异步代码，只需留意代码异步等待某些操作完成时的位置即可。然后，当遇到代码不按预期执行这种棘手问题时，可深入研究一下哪些地方涉及了哪些线程，以及调用栈在任意时间点的样子。（我并没有说这很简单，但理解其机制至少会对我们有所帮助。）

那么，要如何实现GetEnumerator方法呢？首先要知道，我们需要在某个地方存储某个状态。迭代器模式的一个重要方面就是，不用一次返回所有数据——调用代码一次只需获取一个元素。这意味着我们需要确定访问到了数组中的哪个位置。在了解C# 2编译器为我们所做的事情时，迭代器的这种状态特质十分重要，因此，要密切关注本例中的状态。 那么，这个状态值要保存在哪里呢？假设我们尝试把它放在IterationSample类自身里面，让它既实现IEnumerator接口又实现IEnumerable接口。乍一看，这似乎是个好主意—— 毕竟，我们是将数据保存在正确的位置，其中也包括了起点。GetEnumerator方法可以仅返回 this。然而，使用这种方式存在一个大问题——如果GetEnumerator方法被调用了多次，那么 就会返回多个独立的迭代器。例如，我们能使用两个嵌套的foreach语句，以便得到所有可能的成对值。这就意味着，两个迭代器需要彼此独立，每次调用GetEnumerator方法时都需要创建一个新对象。我们仍可以直接在IterationSample内部实现功能，不过只用一个类的话，分工就不明确——那样会让代码非常混乱。 因此，可以创建另外一个类来实现这个迭代器。

我是那种为了在圣诞节到来那一刻尽早打开礼物，宁愿在平安夜熬到凌晨不睡的人。同样，我（这种迫不及待的人）也不可能在向大家展示简洁的C# 2解决方法之前，浪费过多的时间。

这个结果中有几个重要的事情需要牢记：

在第一次调用MoveNext之前，CreateEnumerable中的代码不会被调用；

所有工作在调用MoveNext时就完成了，获取Current的值不会执行任何代码；

在yield return的位置，代码就停止执行，在下一次调用MoveNext时又继续执行；

在一个方法中的不同地方可以编写多个yield return语句；

代码不会在后的yield return处结束，而是通过返回false的MoveNext调用来结束方法的执行。

第一点尤为重要，因为它意味着如果在方法调用时需要立即执行代码，就不能使用迭代器块， 如参数验证。如果你将普通检查放入用迭代器块实现的方法中，将不能很好地工作。你肯定会在某些时候违反这些约束——这是十分常见的错误，而且如果你不知道迭代器块的原理，也很难理解为什么会这样。

书籍介绍

C#语言简洁优雅，精妙强大，是当今编程语言的集大成者，功能不断推陈出新，受到众多开发人员的推崇。本书是C#领域不可多得的经典著作，新版重磅升级，不仅重新组织了内容，还全面更新并细致剖析了C# 6和C# 7的新增特性，为读者奉上知识盛宴。作者在详尽展示C#各个知识点的同时，注重从现象中挖掘本质，解读语言背后的设计思想，深入探究了C#的核心概念和经典特性，并将这些特性融入代码示例，帮助读者顺畅使用C#，享受使用C#编程的乐趣。