《Effective C》21条准则实战解读:在Unity中写出更高质量C代码的完整指南

原创2026-09-24 13:58:041,376 阅读
文章标签:示例工程游戏开发

《Effective C#》21条准则实战解读:在Unity中写出更高质量C#代码的完整指南

导读

本文基于 Unity3DTraining 仓库中的《Effective C#》提炼总结文档,系统梳理了《Effective C# Second Edition》(Bill Wagner 著)中适用于 Unity 引擎 C# 开发的 21 条实战准则。内容覆盖属性与封装、常量选择、类型转换、等同性判断、初始化策略、GC 优化、接口设计与委托事件等核心主题,并结合仓库内的 Delegate_EventTraining 委托事件示例与 DesignPatterns/Singleton 单例源码进行印证。读完本文,你将掌握一套可在 Unity 项目中直接落地的 C# 编码规范,理解每条准则背后的语言机制与性能原理,从而写出更健壮、更高效、更易维护的 C# 代码。


为什么是"21条"而不是"50条"

《Effective C# Second Edition》原书共有 50 条原则,但其中相当一部分是针对纯 .NET 环境(如 WPF、LINQ to Objects、异步 I/O、动态类型等)编写的,并不完全适用于 Unity 内置的 Mono 版 C# 运行时。作者在阅读并做读书笔记时,将不适用于 Unity 的准则略去,同时把适用的准则提炼、合并,最终整理为本文所呈现的 21 条准则。

这里有一个值得注意的细节:最初总结出来的是 22 条,但其中第 22 条(尽量减少在公有 API 中使用动态对象,对应 dynamic 关键字)是纯 .NET 特性,Unity 版本的 Mono 运行时并未实现,因此在严格意义上最终收敛为 21 条。

由于是从原书中"挑出"适用准则,准则序号在原书中并不连续。为了方便阅读,本文对序号进行了重新排列;凡标题序号与原书不一致的准则,都在该条总结末尾注明了对应的原书序号(如"此原则对应于《Effective C# Second Edition》中原则6")。

作为总结式笔记,每条内容都高度概括、理解坡度较陡。若遇到不太理解的地方,建议回到原书(中英文版均可)阅读书中提供的完整代码与示例,掌握效果会事半功倍。

下面先通过一张思维导图纵览全文结构(该思维导图绘制于 22 条时期,其中第 22 条即上文提到的 .NET 动态对象特性,在 Unity 中不适用):

《Effective C#》21条准则总结式思维导图

《Effective C# Second Edition》原书封面

全文 21 条准则按主题可划分为四大板块,下文将逐一展开:

  1. 封装与类型设计(原则 1、12、13、14、15)
  2. 常量、类型转换与条件编译(原则 2、3、4)
  3. 等同性、初始化与 GC(原则 5、6、7、8、9、10、11)
  4. 接口、委托、事件与对象保护(原则 16、17、18、19、20、21)

一、封装与类型设计

原则 1:尽可能地使用属性(property)而不是可直接访问的数据成员

属性一直是 C# 语言中比较有特点的存在。它允许将数据成员作为公有接口的一部分暴露出去,同时仍旧提供面向对象环境下所需的封装。属性这个语言元素可以让你像访问数据成员一样使用它,但其底层依旧是使用方法(get/set 访问器)实现的。

使用属性,可以非常轻松地在 get 和 set 代码段中加入检查机制,例如取值范围校验、惰性加载、日志记录等。

正因为属性是用方法实现的,它拥有方法所拥有的一切语言特性:

  1. 多线程支持非常方便:可以加强 get 和 set 访问器(accessors)的实现来提供数据访问的同步;
  2. 属性可以被定义为 virtual;
  3. 可以把属性扩展为 abstract;
  4. 可以使用泛型版本的属性类型;
  5. 属性也可以定义为接口成员;
  6. 因为实现访问的方法 get 与 set 是两个独立的方法,在 C# 2.0 之后,可以给它们定义不同的访问权限(如 public get / private set),以更好地控制类成员的可见性;
  7. 为了和多维数组保持一致,可以创建多维索引器,在不同的维度上使用相同或不同类型。

结论:无论何时,需要在类型的公有或保护接口中暴露数据,都应该使用属性;如果可以,也应该使用索引器来暴露序列或字典。现在多投入一点时间使用属性,换来的是今后维护时的更加游刃有余。

原则 12:区分值类型和引用类型

在 C# 中,class 对应引用类型,struct 对应值类型。

C# 不是 C++——不能将所有类型定义成值类型并在需要时对其创建引用;C# 也不是 Java——不像 Java 那样所有东西都是引用类型。必须在创建类型时就决定它的表现行为,这相当重要,因为稍后的更改可能带来很多灾难性的问题(例如从 class 改成 struct 会破坏引用语义,反之则会带来大量装箱与堆分配)。

关键判断准则:

  • 值类型无法实现多态,因此其最佳用途就是存放数据;
  • 引用类型支持多态,因此用来定义应用程序的行为。

一般情况下我们习惯用 class,随意创建的大都是引用类型。若下面几点都肯定,那么应该创建 struct 值类型:

  1. 该类型的主要职责在于数据存储吗?
  2. 该类型的公有接口都是由访问其数据成员的属性定义的吗?
  3. 你确定该类型绝不会有派生类型吗?
  4. 你确定该类型永远都不需要多态支持吗?

结论:用值类型表示底层存储数据的类型,用引用类型来封装程序的行为。这样既能保证类暴露出的数据能以副本形式安全提供,也能获得基于栈存储和使用内联方式存储带来的内存性能提升,还可以使用标准的面向对象技术来表达应用程序的逻辑。倘若对类型未来的用途不确定,那么应该选择引用类型。

原则 13:保证 0 为值类型的有效状态

在创建自定义枚举值时,请确保 0 是一个有效的选项。若你定义的是标志(flag)枚举(即添加了 [Flags] 特性),那么可以将 0 定义为没有选中任何状态的标志(比如 None)。

为什么必须如此? 因为值类型变量在默认初始化(如数组元素、字段、default(T))时,其二进制位全部为 0。如果枚举中不存在值为 0 的成员,那么"未初始化"的枚举变量就会落在一个非法状态上,这在 Unity 序列化字段、集合初始化等场景中极易埋下隐患。

作为标记使用的枚举值(即添加了 Flags 特性)应该总是将 None 设置为 0,这也是 .NET 生态中 [Flags] 枚举的通用惯例。

原则 14:保证值类型的常量性和原子性

常量性(immutability) 的类型使得代码更加易于维护。不要盲目地为类型中的每一个属性都创建 get 和 set 访问器——对于那些目的是存储数据的类型,应该尽可能地保证其常量性和原子性。

原子性(atomic)在此处的含义是:类型内部的状态作为一个整体来更新与读取,避免出现"读到一半"的中间状态。常量性则保证:一旦值类型对象创建完成,其内容便不再变化,这使它天然线程安全、可安全共享、便于散列与缓存。

原则 15:限制类型的可见性

在保证类型可以完成其工作的前提下,你应该尽可能地给类型分配最小的可见性——仅仅暴露那些需要暴露的。

  • 尽量使用较低可见性的类(internal、private nested 等)来实现公有接口;
  • 可见性越低,能访问你功能的代码越少,以后可能出现的修改也就越少。

这本质上是信息隐藏原则在类型层面的体现:公有 API 是承诺,暴露得越多,后续演进时被破坏的契约就越多。


二、常量、类型转换与条件编译

原则 2:偏向于使用运行时常量(readonly)而不是编译时常量(const)

对于常量,C# 里有两个不同的版本:

对比维度 编译时常量 const 运行时常量 readonly
取值时机 编译期,值被目标代码中的值直接取代 运行时求值,IL 引用 readonly 变量而非变量值
可用类型 仅能用于数值和字符串 任意类型(如 DateTime 结构)
初始化方式 声明时必须赋值 必须在构造函数或初始化器中初始化(构造函数执行后不能再修改)
实例支持 静态的常量 可以用 readonly 保存实例常量,为类的每个实例存放不同值
性能 略快(使用已知常量值比访问 readonly 值略高一点,但提升微乎其微) 略慢但更灵活

适用建议:

  • 应该尽量使用运行时常量,虽然编译器常量略快,但并没有运行时常量那么灵活;
  • 应仅仅在那些性能异常敏感,且常量的值在各个版本之间绝对不会变化时,再使用编译时常量;
  • 需要在编译时才确定的值,最好使用运行时常量;
  • 标记版本号的值就应该使用运行时常量,因为它的值会随着每个不同版本的发布而改变;
  • 在编译器必须得到确定数值的场景(如特性 attribute 的参数、枚举的定义)以及那些各个版本发布之间不会变化的值,一定要使用 const;
  • 除此之外的所有情况,都应尽量选择更加灵活的 readonly 常量。

原则 3:推荐使用 is 或 as 操作符而不是强制类型转换

C# 中 is 和 as 操作符的用法概括如下:

  • is:检查一个对象是否兼容于其他指定的类型,返回一个 Bool 值,永远不会抛出异常;
  • as:作用与强制类型转换一样,但是永远不会抛出异常——如果转换不成功,会返回 null。

核心建议:

  • 尽可能使用 as 操作符,因为相对于强制类型转换来说,as 更加安全,也更加高效;
  • as 在转换失败时会返回 null,在转换对象本身是 null 时也会返回 null,所以使用 as 进行转换时,只需检查返回的引用是否为 null 即可;
  • as 和 is 操作符都不会执行任何用户自定义的转换,它们仅当运行时类型符合目标类型时才能转换成功,也不会在转换时创建新的对象;
  • as 运算符对值类型无效,此时可以使用 is,配合强制类型转换进行转换(如 if (obj is int) { int i = (int)obj; });
  • 仅当不能使用 as 进行转换时,才应该使用 is 操作符,否则 is 就是多余的。

原则 4:推荐使用条件属性(Conditional)而不是 #if 条件编译

#if/#endif 很容易被滥用,使得编写的代码难于理解且更难于调试。C# 为此提供了条件特性(Conditional attribute)。使用条件特性可以将函数拆分出来,让其只有在定义了某些环境变量或设置了某个值之后才能编译并成为类的一部分。

Conditional 特性最常用的地方就是将一段代码变成调试语句。经典场景是:

[System.Diagnostics.Conditional("DEBUG")]
private void Log(string message) { /* ... */ }

当工程未定义 DEBUG 符号时,所有对该方法的调用都会被编译器从 IL 中剥离,而方法定义本身仍保留。

使用约束:

  • Conditional 特性只可应用在整个方法上;
  • 任何一个使用 Conditional 特性的方法都只能返回 void 类型;
  • 不能在方法内的代码块上应用 Conditional 特性;
  • 不可以在有返回值的方法上应用 Conditional 特性;
  • 应用了 Conditional 特性的方法可以接受任意数目的引用类型参数。

优势:使用 Conditional 特性生成的 IL 要比使用 #if/#endif 时更有效率(调用点连同参数一起被移除,而不是留下一段空代码);同时,将其限制在函数层面上可以更加清晰地将条件性的代码分离出来,保证代码的良好结构。


三、等同性、初始化与 GC

原则 5:理解几个等同性判断之间的关系

C# 中可以创建两种类型:值类型和引用类型。如果两个引用类型的变量指向的是同一个对象,它们被认为是"引用相等";如果两个值类型的变量类型相同且包含同样的内容,它们被认为是"值相等"。这正是等同性判断需要如此多方法的原因。

当我们创建自己的类型时(无论是类还是 struct),应为类型定义"等同性"的含义。C# 提供了 4 种不同的函数来判断两个对象是否"相等":

  1. public static bool ReferenceEquals(object left, object right); —— 判断两个不同变量的**对象标识(object identity)**是否相等。无论比较的是引用类型还是值类型,该方法判断的依据都是对象标识,而不是对象内容;
  2. public static bool Equals(object left, object right); —— 用于判断两个变量的运行时类型是否相等;
  3. public virtual bool Equals(object right); —— 实例方法,用于重载,自定义类型时应覆写它来定义自己的相等语义;
  4. public static bool operator ==(MyClass left, MyClass right); —— 用于重载相等运算符。

覆写规则:

  • 不应该覆写 Object.ReferenceEquals() 静态方法和 Object.Equals() 静态方法,因为它们已经完美地完成了所需的工作,提供了与运行时具体类型无关的正确判断;
  • 对于值类型,我们应该总是覆写 Object.Equals() 实例方法和 operator ==(),以便为其提供效率更高的等同性判断(避免默认实现的装箱与反射开销);
  • 对于引用类型,仅当你认为"相等"的含义并非对象标识相等时,才需要覆写 Object.Equals() 实例方法;
  • 在覆写 Equals() 时,也要实现 IEquatable<T> 接口,为强类型场景提供无装箱的相等性比较。

此原则对应于《Effective C# Second Edition》中原则 6。

原则 6:了解 GetHashCode() 的一些坑

GetHashCode() 方法在使用时会有不少坑,要谨慎使用。

它只在一个地方被使用:为基于散列(hash)的集合定义键的散列值,此类集合包括 HashSet<T> 和 Dictionary<K,V> 容器等。对引用类型来讲,虽然可以正常工作,但是效率很低;对值类型来讲,基类中的实现有时甚至不正确。而且,自己编写的 GetHashCode() 也不可能既有效率又正确——所以对自定义类型要格外谨慎。

在 .NET 中,每个对象都有一个散列码,其值由 System.Object.GetHashCode() 决定。

实现自己的 GetHashCode() 时,要遵循以下三条原则:

  1. 相等对象必须生成相同的散列码:如果两个对象相等(由 operator== 定义),那么它们必须生成相同的散列码。否则,这样的散列码将无法用来查找容器中的对象(散列容器的"先比较散列码、再比较相等"机制会直接失效);
  2. 散列码必须保持不变:对于任何一个对象 A,A.GetHashCode() 必须保持不变。这意味着散列码的参与字段一旦对象被放入散列容器,就不能再变化(否则对象会在容器中"丢失");
  3. 分布均匀:对于所有的输入,散列函数应该在所有整数中按随机分布生成散列码。这样散列容器才能得到足够的效率提升(减少冲突与退化)。

此原则对应于《Effective C# Second Edition》中原则 7。

原则 7:理解短小方法的优势

将 C# 代码翻译成可执行的机器码需要两个步骤:

  1. C# 编译器生成 IL,并放在程序集中;
  2. JIT 根据需要逐一为方法(或一组方法,如果涉及内联)生成机器码。

短小的方法让 JIT 编译器能够更好地平摊编译的代价(编译一个短方法与一个长方法的固定开销相近,短方法使每次编译投入产出比更高);短小的方法也更适合内联——内联能消除调用开销,但只有足够短小的方法才值得且可能被 JIT 内联。

除了短小之外,简化控制流程也很重要:控制分支越少,JIT 编译器也会越容易地找到最适合放在寄存器中的变量,从而生成更高效的机器码。

所以,短小方法的优势,不仅体现在代码的可读性上,还关系到程序运行时的效率。这也与 Unity 的 IL2CPP / Mono 编译管线中 JIT 与 AOT 的优化策略相呼应——清晰的、短小的、低分支的方法始终是编译器友好的代码。

此原则对应于《Effective C# Second Edition》中原则 11。

原则 8:选择变量初始化器而不是赋值语句

成员初始化器(在字段声明处直接 = 初始值)是保证类型中成员均被初始化的最简单的方法——无论调用的是哪一个构造函数。初始化器将在所有构造函数执行之前执行。

使用这种语法也就保证了你不会再添加新的构造函数时遗漏掉重要的初始化代码——因为初始化逻辑集中在字段声明处,新增构造函数时无需再复制一遍。

结论:若是所有的构造函数都要将某个成员变量初始化成同一个值,那么应该使用初始化器,而不是在每个构造函数里重复赋值。

此原则对应于《Effective C# Second Edition》中原则 12。

原则 9:正确地初始化静态成员变量

C# 提供了静态初始化器(static 字段声明处赋值)和静态构造函数(static 构造函数)两种机制,专门用于静态成员变量的初始化。

  • 静态构造函数是一个特殊的函数,将在其他所有方法执行之前以及变量或属性被第一次访问之前执行。可以用这个函数来初始化静态变量、实现单例模式,或执行类可用之前必须进行的任何操作;
  • 和实例初始化一样,也可以使用初始化器语法来替代静态构造函数。若只是需要为某个静态成员分配空间,那么不妨使用初始化器的语法;而若是需要更复杂的逻辑(多语句、分支、循环等)来初始化静态成员变量,那么可以使用静态构造函数;
  • 使用静态构造函数而不是静态初始化器最常见的理由就是处理异常:在使用静态初始化器时,我们无法自己捕获异常;而在静态构造函数中却可以做到(通过 try/catch 包装初始化逻辑)。

仓库印证:仓库 DesignPatterns/Singleton 目录下提供了多个单例实现,正是本条准则的典型应用场景:

  • UnitySingleton.cs:基于 MonoBehaviour 的 Unity 单例,在 Awake() 中缓存静态实例;
  • EagerSingleton.cs:饿汉式单例——"在装载类的时候(静态初始化器执行时)就创建实例",是典型的"空间换时间",类装载时创建、调用时无需判断;
  • SyncLazySingleton.cs:双重检查加锁的懒汉式单例——先检查实例是否存在(第一重检查),不存在才进入同步块,在同步块内再次检查(第二重检查)后才创建实例。这样只在第一次创建实例时同步,以后无需同步,既保证线程安全又避免性能损耗。

此原则对应于《Effective C# Second Edition》中原则 13。

原则 10:使用构造函数链(减少重复的初始化逻辑)

编写构造函数很多时候是个重复性的劳动。如果发现多个构造函数包含相同的逻辑,可以将这个逻辑提取到一个通用的构造函数中。这样既可以避免代码重复,也可以利用构造函数初始化器来生成更高效的目标代码。

C# 编译器将构造函数初始化器(this(...) / base(...))看做是一种特殊的语法,并会移除掉重复的变量初始化器以及重复的基类构造函数调用。这样最终的对象可以执行最少的代码来保证初始化的正确性——初始化器中的语句只执行一次,而不是在每个构造函数中重复执行。

构造函数初始化器允许一个构造函数去调用另一个构造函数(链式调用)。而 C# 4.0 添加了对默认参数的支持,这个功能也可以用来减少构造函数中的重复代码:可以将某个类的所有构造函数统一成一个,并为所有的可选参数指定默认值,其他的几个构造函数(或调用方)只需调用该构造函数并提供不同的参数即可。

此原则对应于《Effective C# Second Edition》中原则 14。

原则 11:实现标准的销毁模式(降低 GC 工作量)

GC 可以高效地管理应用程序使用的内存。不过创建和销毁堆上的对象仍旧需要时间——若是在某个方法中创建了太多的引用类型对象,将会对程序的性能产生严重的影响(分配开销 + GC 压力 + 可能的暂停)。

这里有一些规则,可以帮你尽量降低 GC 的工作量:

  1. 提升局部变量为成员变量:若某个引用类型(值类型无所谓)的局部变量用于被频繁调用的例程中,那么应该将其提升为成员变量,避免每次调用都新建对象;
  2. 为常用的类型实例提供静态对象:将频繁创建、内容不变的实例缓存为静态对象复用;
  3. 创建不可变类型的最终值:比如 string 类的 += 操作符会创建一个新的字符串对象并返回,多次使用会产生大量垃圾,不推荐使用。对于简单的字符串操作,推荐使用 string.Format;对于复杂的字符串操作,推荐使用 StringBuilder 类。

这条准则对 Unity 尤为重要:移动端平台的托管堆有限,每帧频繁的字符串拼接(如日志、UI 文本、网络消息拼接)是 GC 压力的主要来源之一。仓库中 Doc/Unity GC.png 与 Doc/Unity GC2.png 等资料也从 GC 原理层面佐证了这条准则的实践价值。

此原则对应于《Effective C# Second Edition》中原则 16。


四、接口、委托、事件与对象保护

原则 16:通过定义并实现接口来替代继承

理解**抽象基类(abstract class)和接口(interface)**的区别:

  1. 本质差异:接口是一种契约式的设计方式,一个实现某个接口的类型,必须实现接口中约定的方法;抽象基类则为一组相关的类型提供了一个共同的抽象。也就是说,抽象基类描述了对象是什么(is-a),而接口描述了对象将如何表现其行为(can-do);
  2. 实现与数据:接口不能包含实现,也不能包含任何具体的数据成员;而抽象基类可以为派生类提供一些具体的实现(字段、方法体、默认行为);
  3. 组织方式:基类描述并实现了一组相关类型间共用的行为;接口则定义了一组具有原子性的功能,供其他不相关的具体类型来实现(一个类型可以实现任意多个接口,但只能继承一个基类)。

理解好两者之间的差别,便可以创造更富表现力、更能应对变化的设计:使用类层次来定义相关的类型,用接口暴露功能,并让不同的类型实现这些接口。这在 Unity 项目中尤其常见——例如把可交互对象、可受伤对象、可拾取对象抽象为接口,让怪物、玩家、宝箱等互不相关的类各自实现。

此原则对应于《Effective C# Second Edition》中原则 22。

原则 17:理解接口方法和虚方法的区别

第一眼看来,实现接口和覆写虚方法似乎没有什么区别;实际上,两者之间的差别很大:

  1. 默认非虚:接口中声明的成员方法默认情况下并非虚方法,所以派生类不能覆写基类中实现的非虚接口成员。若要覆写的话,将接口方法声明为 virtual 即可;
  2. 默认实现与继承:基类可以为接口中的方法提供默认的实现,随后,派生类可以声明其实现了该接口,并从基类中继承该实现;
  3. 选择更多:实现接口拥有的选择要比创建和覆写虚方法多。可以为类层次创建密封(sealed)的实现、虚实现或者抽象的契约;还可以创建密封的实现,并在实现接口的方法中提供虚方法进行调用(模板方法式的组合)。

这条准则提醒我们:接口实现与虚方法重写是两种不同的多态手段,在面向接口编程时要清楚各自的分派语义,避免写出"以为覆写了接口方法实际却没有生效"的代码。

此原则对应于《Effective C# Second Edition》中原则 23。

原则 18:用委托实现回调

在 C# 中,回调是用委托来实现的,主要要点如下:

  1. 类型安全的回调:委托为我们提供了类型安全的回调定义。虽然大多数常见的委托应用都和事件有关,但这并不是 C# 委托应用的全部场合。当类之间有通信的需要,并且期望一种比接口所提供的更为松散的耦合机制时,委托便是最佳的选择;
  2. 运行时配置目标、通知多客户:委托允许我们在运行时配置目标并通知多个客户对象。委托对象中包含一个方法的引用,该方法可以是静态方法,也可以是实例方法。也就是说,使用委托,我们可以和一个或多个在运行时联系起来的客户对象进行通信;
  3. lambda 精简语法:由于回调和委托在 C# 中非常常用,以至于 C# 特地以 lambda 表达式的形式为其提供了精简语法;
  4. 多播委托的异常语义:由于一些历史原因,.NET 中的委托都是多播委托(multicast delegate)。多播委托调用过程中,每个目标会被依次调用。委托对象本身不会捕捉任何异常,因此,任何目标抛出的异常都会结束委托链的调用(后续目标不再执行)。

仓库印证:仓库 Effective C#/Delegate_EventTraining 是一个专门的委托与事件训练工程,其中 NoDelegate.cs 与 UseDelegate.cs 形成鲜明对比:

  • 不使用委托(NoDelegate.cs):在 GoodMorning 方法里用 switch (language) 手工分支选择"中文问候"或"英文问候",每新增一种语言都要改分支逻辑;
  • 使用委托(UseDelegate.cs):先定义 public delegate void MoringDelegate(string name);,然后在 BtnClick() 中直接传入 MoringEnglish / MoringChinese 两个方法作为参数(GoogMoring("msxher", MoringEnglish)),方法的选择权从编译期推迟到了运行时,新增问候语无需修改业务逻辑,这正是准则中"委托在运行时配置目标、提供比接口更松散的耦合"的直观演示。

此原则对应于《Effective C# Second Edition》中原则 24。

原则 19:用事件模式实现通知

  • 事件提供了一种标准的机制来通知监听者,而 C# 中的事件其实就是观察者模式的一个语法上的快捷实现;
  • 事件是一种内建的委托,用来为事件处理函数提供类型安全的方法签名。任意数量的客户对象都可以将自己的处理函数注册到事件上,然后处理这些事件;这些客户对象无需在编译时就给出,事件也不必非要有订阅者才能正常工作(没有订阅者时触发事件不会报错);
  • 在 C# 中使用事件可以降低发送者和可能的通知接受者之间的耦合:发送者可以完全独立于接受者进行开发,发送者不知道也不关心谁在监听,接受者通过 += / -= 自由地订阅或退订。

在 Unity 项目中,这一模式广泛用于 UI 事件、游戏状态变化通知、跨模块通信等场景,配合上面的委托训练工程(Delegate_EventTraining 中使用 EventDelegate.Add(...) 注册 NGUI 按钮点击回调)可以直观体会到"事件 = 委托 + 订阅/退订"的完整闭环。

此原则对应于《Effective C# Second Edition》中原则 25。

原则 20:避免返回对内部类对象的引用

若将引用类型通过公有接口暴露给外界,那么对象的使用者即可绕过我们定义的方法和属性来更改对象的内部结构,这会导致常见的错误(例如集合被外部直接 Add/Clear、内部状态被外部任意篡改而失去一致性)。

共有四种不同的策略可以防止类型内部的数据结构遭到有意或无意的修改:

  1. 值类型:当客户代码通过属性来访问值类型成员时,实际返回的是值类型的对象副本,修改副本不会影响内部状态;
  2. 常量类型:如 System.String,本身不可变,返回引用也无法修改其内容;
  3. 定义接口:将客户对内部数据成员的访问限制在一部分功能中(例如只暴露只读接口、或者只暴露查询方法的接口);
  4. 包装器(wrapper):提供一个包装器,仅暴露该包装器,从而限制对其中对象的访问(例如 ReadOnlyCollection<T> 这类只读视图)。

此原则对应于《Effective C# Second Edition》中原则 26。

原则 21:仅用 new 修饰符处理基类更新

使用 new 操作符修饰类成员可以重新定义(隐藏)继承自基类的非虚成员。

需要注意:

  • new 修饰符只是用来解决升级基类所造成的基类方法和派生类方法冲突的问题——当基类在新版本中新增了一个与派生类现有方法同名的成员时,用 new 显式声明"派生类的方法隐藏基类方法",消除编译警告并明确语义;
  • new 操作符必须小心使用。若随心所欲地滥用,会造成对象调用方法的二义性——同样的代码在静态类型不同的引用下,会调用到不同的方法,极易引发难以排查的 bug。

使用 new 隐藏成员与使用 override 覆写虚成员是两种完全不同的语义:前者是"换了一个新成员,与基类成员无关",后者是"扩展基类成员的行为"。区分清楚这一点,才能避免设计上的混乱。

此原则对应于《Effective C# Second Edition》中原则 33。


总结:21 条准则的实践优先级

综合来看,这 21 条准则在 Unity 项目中可以按"性价比"分成三个层次落地:

  • 立即可用、收益立竿见影:原则 1(属性封装)、原则 2(readonly 优先)、原则 3(is/as 转换)、原则 7(短小方法)、原则 8/10(初始化器与构造函数链)、原则 11(降低 GC 工作量)——这些不改变架构,改代码风格即可受益;
  • 设计层面、需要刻意练习:原则 5/6(等同性与散列码)、原则 12/13/14(值类型设计)、原则 16/17(接口 vs 继承)、原则 18/19(委托与事件)、原则 20/21(对象保护与 new 修饰符)——这些决定类型与模块的设计质量;
  • 防御性编程:原则 4(Conditional 代替 #if)、原则 9(静态初始化与单例)、原则 15(限制可见性)——这些让代码更健壮、更安全。

每一条准则都值得回到原书《Effective C# Second Edition》中阅读配套的完整代码示例。本文作为总结式提炼,提供的是"知识梗概"与"仓库级印证";而仓库中 Delegate_EventTraining(委托与事件实战)和 DesignPatterns/Singleton(单例模式的多种静态初始化实现)正是将其中几条准则落到真实 Unity 工程的参考范本。

后续在 Unity 项目中可以以此为检查清单:每次 Code Review 时,用这 21 条准则逐条审视新代码,坚持一段时间后,C# 代码质量与维护体验的提升会非常明显。

登录后查看全文
Unity3DTraining