更锋利的C#代码

第1章 基本的代码风格

1.1 换行的讲究

1.1.1 寻找最佳的断行位置

1.1.2 每行只写一条语句

1.1.3 分行定义变量

1.2 避免代码过于拥挤

1.2.1 使用空行分隔代码块

1.2.2 使用空格降低代码密度

1.3如何缩进

1.3.1 嵌套或包含关系引起的缩进

1.3.2 因换行而产生的缩进

1.3.3 使用空格还是Tab键

1.4 大括号

1.4.1 大括号的位置

1.4.2 空的大括号结构

1.4.3 仅包含单个语句的结构体

1.5 保持项目文件的条理性

1.5.1 解决方案的结构呼应

1.5.2 代码文件的结构

1.5.3 使用#region标记来隐藏细节

第2章 养成良好的注释习惯

2.1 何时需要注释

2.1.1 解释代码的意图

2.1.2 对局部变量的说明

2.1.3 充当代码标题

2.1.4 指出例外情况

2.1.5 开发过程的提示

2.2 注释的格式

2.2.1 单行注释

2.2.2 多行注释

2.3 正确使用XML文档注释

2.3.1 结构与类的XML文档注释

2.3.2 属性的XML文档注释

2.3.3 方法的XML文档注释

2.3.4 构造函数的XML文档注释

2.3.5 事件的XML文档注释

2.3.6 枚举类型的XML文档注释

2.3.7 泛型的XML文档注释

2.3.8 其他标记

第3章一般命名规范

3.1 选用合适的名称

3.1.1 使用字符的限制

3.1.2 使用含义明确的英语

3.2 大小写规则

3.2.1 Pascal规则

3.2.2 Camel规则

3.2.3 首字母缩写词与简写词

3.2.4 应在何时使用何种大小写规则

3.3 考虑跨语言编程

3.3.1 不要通过大小写区分标识符

3.3.2 避免与其他语言的关键字重复

3.3.3 避免使用特定语言的术语

3.4 命名一致与冲突

3.4.1 大小写无关原则

3.4.2 对基类型的命名暗示

3.4.3 对参数与属性的关系暗示

3.4.4 属性名称与自身类型同名

3.4.5 与命名空间相关的命名冲突

3.5 匈牙利命名法

3.5.1 匈牙利命名法的弊端

3.5.2 考虑为控件应用匈牙利命名法

第4章处理数据

4.1 关于数据类型

4.1.1 整数

4.1.2 浮点数

4.1.3 布尔类型

4.1.4 字符与字符串

4.2 变量的使用

4.2.1 尽可能使用内置关键字

4.2.2初始化一切变量

4.2.3 集中使用变量

4.3 使用枚举

4.3.1 何时使用枚举

4.3.2 如何为枚举命名

4.3.3 关于枚举项

4.3.4 标记枚举

4.4 魔数——以字面数值出现在代码中的常量

4.5 复杂的表达式

4.5.1 运算符的副作用

4.5.2简化表达式

第5章分支结构

5.1 使用if结构

5.1.1“==”与“=”的问题

5.1.2 如何处理复杂的条件

5.2 使用switch结构

5.2.1 break语句

5.2.2 使用default子句要注意的问题

5.3 选择if还是switch

5.4 关于判断顺序的设计

5.4.1 先判断最有可能成立的条件

5.4.2 预防因条件短路而丟失操作

5.5 慎用goto语句

第6章 循环结构

6.1 使用for还是while

6.1.1 for和while的语义比较

6.1.2 简单的数值迭代——for和while的思维模式的差j

6.1.3 预知循环次数——微波炉加热的启示

6.1.4 集合迭代——独特的foreach结构

6.2 循环变量的使用

6.2.1 循环变量的命名

6.2.2 循环变量的定义

6.2.3 避免循环变量的非常规应用

6.3 提高循环效率

6.3.1 避免不必要的重复劳动

6.3.2 避免不必要的循环

第7章 如何使用函数

7.1 为什么要使用函数

7.1.1 函数与方法

7.1.2 代码复用

7.1.3 隐藏细节——使用函数进行抽象

7.2 函数重载

7.2.1 重载的语义——为调用者提供方便

7.2.2 保持核心代码唯一

7.3 参数的设计

7.3.1 参数的命名

7.3.2 不要使用保留项.

7.3.3 何时使用变长参数列表

7.3.4 何时使用ref参数和out参数

7.3.5参数的顺序

7.3.6 重载函数的参数一致性体现

7.4 参数检查的必要性

7.4.1 检查零值及空引用

7.4.2 检查枚举类型

7.4.3 防止数据被篡改

7.4.4 在何处检查合法性

7.5 函数的出口——离开函数的三种方式

7.5.1 返回值的用法

7.5.2 离开函数的时机

第8章 结构与类

8.1 结构与类的比较

8.1.1 值类型与引用类型

8.1.2 何时应当使用结构

8.1.3 何时应当使用类

8.2 结构与类的命名

8.2.1 措辞

8.2.2 避免与命名空间冲突

8.2.3 不要使用“C”前缀

8.2.4后缀的使用

8.3 如何搭建一个典型的结构

8.3.1 找准核心数据

8.3.2 数据的表现形式

8.3.3 定义等价原则

8.3.4实现基本运算

8.4 如何真正面向对象

第9章 封装

9.1 构造函数

9.1.1 构造函数的语义

9.1.2 何时使用静态构造方法

9.1.3 构造函数的参数及其初始化

9.2 Finalize函数

9.2.1 垃圾回收器

9.2.2 IDisposable接口——显式释放资源的方法

9.2.3 释放资源的一般范式

9.3 何时应该使用字段

9.3.1 存储核心数据

9.3.2 维持中间结果

9.3.3 常量字段

9.4 如何使用字段

9.4.1 字段的命名

9.4.2 访问控制

9.5 何时应该使用属性

9.5.1 属性的语义

9.5.2 数据访问控制

9.5.3 需要的后续操作

9.5.4 简单的数据处理

9.5.5 预定义的对象实例

9.6 如何使用属性

9.6.1 属性的命名

9.6.2 访问控制

9.6.3 提供合理的默认值

9.6.4 保持轻量级的操作

9.6.5 在属性中抛出异常

9.7 何时应该使用方法

9.7.1 表示某种操作

9.7.2 耗时的任务——方法在形式上的暗示作用

9.7.3 有副作用的操作

9.7.4 返回不确定的值

9.7.5 返回数组或集合对象

9.8 如何使用方法

9.8.1 方法的命名

9.8.2 检查传入的参数

9.9 静态类型及成员

9.10 嵌套类型及其适用场合

9.11 可变类型的安全性

9.12 使用程序集与命名空间

9.12.1 程序集的划分

9.12.2 为什么要使用命名空间

9.12.3 命名空间的命名

9.12.4 命名空间的管理

第10章 继承与多态

10.1 如何利用类继承

10.1.1 自上而下逐步细化

10.1.2 自下而上逐步抽象

10.2 继承限制

10.2.1 强制继承的抽象类型

10.2.2 密封类型

10.2.3 扩展方法——直接向已有类型添加功能

10.3 关于接口

10.3.1 接口的语义

10.3.2 接口的命名

10.3.3 使用接口还是类继承

10.4 何时应当显式实现接口

10.4.1 解决接口之间的命名冲突

10.4.2 提供强类型操作

10.4.3 隐藏仅用于通过接口访问的成员

10.5 使用多态

10.5.1 何时应进行重写

10.5.2 应当重写哪个成员

10.5.3 保持参数名称一致

10.6运算符重载

10.6.1 可重载的运算符

10.6.2 符合运算符的本意

10.6.3 运算符的关联性

10.6.4 类型转换运算符的重载

第11章 泛型机制

11.1 装箱与取消装箱

11.2 何时使用泛型

11.3 泛型的类型参数设计

11.3.1 类型参数的命名

11.3.2 使用类型参数的时机

第12章 事件与委托

12.1 何为事件驱动模式

12.2 如何响应事件

12.2.1 事件处理函数

12.2.2代码的分配

12.2.3 事件侦听器的使用

12.3如何提供事件

12.3.1 何时应当提供事件

12.3.2 事件的命名

12.3.3 传递与事件相关的数据

12.3.4 用于事件的委托及其要遵守的约定

12.3.5 触发事件

12.4 使用委托

12.4.1 何时使用委托

12.4.2 何时使用匿名方法

12.4.3 基类型与派生类型

第13章 集合类型

13.1 系统内置集合类型

13.1.1 数组

13.1.2 列表

13.1.3 字典

13.1.4 其他类型

13.2 选用适当的集合类型要考虑的几个方面

13.2.1 容量

13.2.2进出次序

13.2.3 定位的问题——索引／键访问

13.2.4 元素结构

13.2.5 排序

13.3 性能比较

13.4 提供自己的集合类型

13.4.1 何时应提供集合类型

13.4.2 集合类型的命名

13.4.3 提供与内置集合类型一致的行为

13.4.4 索引器及其应遵守的规则

13.4.5 迭代器

第14章 LINQ查询

14.1 提高LINQ查询的效率

14.1.1 查询语法和方法语法的区别

14.1.2 LINQ查询的创建、执行与性能

14.1.3 减少返回的数据量

14.2 LINQ中的错误处理一一采用防御式编程

14.3 LINQ查询的相关机制

14.3.1 匿名类型

14.3.2 隐式类型的局部变量

14.3.3 Lambda表达式与匿名函数

第15章 异常

15.1 处理异常时应遵守的规范

15.2 抛出异常

15.2.1 异常的语义

15.2.2 不应使用异常的位置

15.2.3 控制异常

15.2.4 异常的重新抛出——重新包装时要注意的

15.3 选用合适的异常类型

15.3.1 常见的异常类型

15.3.2 不应使用的异常类型

15.4 异常提示信息

15.5 设计自定义异常及应遵循的约定

第16章 全球化与本地化

16.1 分离与特定区域相关的信息

16.2 处理特定区域性的数据

16.2.1 区分区域性与界面区域性

16.2.2 在内部使用Unicode

16.2.3 文本的比较与排序

16.2.4 不要假定区域性的行为

16.3 何时使用固定区域性

16.4 用户界面应注意的细节

16.4.1 使用资源

16.4.2 术语

16.4.3 界面布局

16.4.4 歧义

16.4.5 组合文本

附录A：C#、VB.NET、J#关键字表

附录B：常用的异常类型

一个好的程序，不仅仅是能得出正确的运行结果，而且还应在其内部保持清晰的代码逻辑和语义，否则，跟随在正常结果之后的也许是艰难的代码维护工作，对程序进行一处修改往往会牵一发而动全身，一不小心就会埋下深深的陷患。从另一个角度来说，如果每一行代码的质量都很高，那么这个软件产品也一定是高质量的。这就像ISO 9000的质量体系认证一样，与其在产品生产完成之后再进行检验，不如控制每一步生产环节的质量。本书由浅入深、由表及里地讲述存在于C#编码开发中的各种质量问题，让读者清楚地了解什么是应该做的，什么是不应该做的。C#提供的每种语言机制的功能背后，体现了怎样的逻辑含义。当遇到具体的问题时，应该如何选择与取舍。阅读完此书的每一个章节，都会让读者站在更高的角度C#体系拥有更深的认识和把握，不断向软件开发的更高层次迈进。

《更锋利的C#代码：编写高质量C#程序》由清华大学出版社出版。
一个好的程序，不仅仅是能得出正确的运行结果。每个章节的内容似乎都为大家所熟悉，然而视角完全不同。通过对那些几乎被人们忽视了的细节的精心处理，不断地提高每一行代码的质量。它们为什么必须是，而并非形式主义。C＃提供的每种语言机制的功能背后，体现了怎样的逻辑含义。读完此书，你会站在更高的角度与C＃体系拥有更深的认识和把握。