C#的进化——C#发展史、C#1.0-10.0语法系统性梳理、C#与JAVA的对比

C#的进化 C#发展史、C#1.0-10.0语法系统性梳理、C#与JAVA的对比

前言

C#也使用了十年有余了。

一路走来，见证了微软从封闭走向开放，从平台捆绑，到成为活跃于Github的重要贡献者。亲历了C#的开创性引领和影响了诸多语言，也看到了其他语言的优秀机制被有机的融合进C#（好吧，我承认语言之间都在互相抄）。在微软的“开发者至上”理念加持下，C#变得越来越好用。如今，.Net 6已经发布，这是.Net家族结束混乱的割据，统一后的第一个LTS版本，也是号称迄今为止最快的.Net。回顾C#的发展历史，一路走来感慨万千。本着温故而知新的精神，和CShaper那该死的想要“安利”的冲动，感觉是时候对C#做个全面的总结了。

写本文还有一个现实原因：在如今的各大技术区中，鲜有细致地讲解C#全版本语法特点（Feature）的文章。而我也发现有不少博主对一些语法理解有所偏差，例如：大多数的文章都没能很好的阐述C#中枚举器（IEnumerator）和迭代器（Iterator）的区别，也没有很好的说明LINQ和迭代器的紧密联系。而对C#语法和Java语法做出全面对比的文章也不是很多。作者希望通过此一文填补这些空缺。

本文将以C#版本为时间线，从C#1.0到C#10.0梳理每个版本的语法。并尽可能与Java做出对比。

本文目标人群主要是：

1. CShaper：
   1. 想对C#从1.0到10.0的语法特点进行系统梳理的人。
   2. 计划转Java，或者纯粹好奇，想了解C#与Java有哪些异同的人。
2. Javaer，或者其他非C#的开发者：
   1. 对C#好奇，想对C#做个全面了解的人。
   2. 计划转C#，通过此文可以直接上手开发的人。（我知道没有）

本文旨在：

1. 对C#每个版本引入的语法做系统性梳理。
   • 对于老版本，发掘容易忽略的细节，纠正理解上的谬误。
   • 对于新版本，帮助那些对官方文档抱有“英文懒得看，中文看不懂”态度的人，整理和提炼新版本的语法特点。
2. 介绍C#的同时，就语言机制与Java做出对比。让读者能够一次性掌握两种语言的特点和差异。
3. 用词尽量严谨、规范。部分关键名词给出翻译前的原始英文。以免产生谬误而误导读者。
4. 同时照顾CShaper和没有C#开发经验的人，让两者都有所收获。

本文假设阅读者已有一定语言基础，因而不会讲过于基础且与Java无异的部分。但是，如果基础部分与Java有所不同，会指出与Java的不同之处。与Java的对比部分将使用下面的格式：

在语法的更进上，C#与Java的采用完全不同的策略：C#的更新相对激进，每个版本都会有不少的更新升级，也大量引入了已在其他语言上实现了的优秀机制；Java则以稳字当头，每个版本关于语法层面的更新内容都不是很多，而且往往新的语法都是先发布预览版，在几个Java版本之后才会发布正式版。

本文对C#的语法描述时，如果需要提及更高版本的C#才支持的语法，会显著的标明支持的C#版本。而与Java对比时，因为在如今的使用场景中，开发者基本上至少会使用Java 8以上的版本，所以仅在所涉及的Java语法需要9以上的版本时，才会明确标注所需的Java版本。

为了同时照顾Javaer和CShaper甚至其他语言开发者，本文篇幅会较长（接近15万字）。但是每个知识点的文字其实并不多。读者可以根据需要从目录快速定位到关注的章节（其实你还可以使用搜索大法）。不过，本文的撰写方式，具有知识延续性：每个章节的介绍会假设之前章节介绍的内容读者已经掌握。因而对于非CShaper而言，跳过章节需要慎重，可能会使相应章节的部分名词和代码难以理解。

---

目录

• 前言
• 目录
• 正文之前
  • 基本概念
    • C#
    • .Net
  • .Net和C#发展史
  • 本文的重点是语法，而非类库
• Hello World
  • 命名空间（Namespace）
  • using语句
• C# 1.0 —— Java的替代品
  • 类（Class）和结构（Struct）
    • Class与Struct的区别
    • 修饰符（Modifier）
      • 可访问性修饰符（Access Modifier）
      • 其他修饰符
    • 类型别名
    • 隐式继承、Object类
    • 值类型 vs 引用类型
    • 值类型（Value Type）
      • 结构
      • 装箱（Boxing）和拆箱（Unboxing）
      • 枚举（Enum）
    • 引用类型（Reference Type）
      • 数组（Array）
      • 类（Class）
        • 类的继承
        • 嵌套类
    • 方法（Method）
      • 方法的参数
        • out和ref关键词
        • 参数默认值
        • 可变参数
      • 构造器（Constructor）、终结器（Finalizer）
        • 静态构造器（Static Constructor）
        • 构造器串联
        • 终结器（Finalizer）
      • 多态（Polymorphism）
    • 属性（Property）
  • 接口（Interface）
    • 可释放接口（IDisposable）
      • using自动释放语句
      • IDisposable释放模式
    • 枚举器接口（IEnumerator） 和 可枚举接口（IEnumerable）
  • 委托（Delegate）
    • 多播委托（Multicast Delegate）
  • 事件（Event）
  • 运算符（Operator）
    • 特色运算符
      • @符号
      • default运算符
      • null判断运算符
    • 运算符的特色语法
      • 索引器（Indexer）
      • 运算符重载（Operator Overloading）
        • string的==
        • DateTime的+、-、>、<、>=、<=
      • 自定义类型转换（User-Defined Conversion Operator）
  • 语句（Statement）
    • lock
    • 说明注释（文档性注释，Documentation Comment）
    • 预处理指令（Preprocessor Directive）
      • #define和#if
      • #region
  • 特性（Attribute）
    • 显式指定特性的目标
    • 特性中的@符号
  • 反射（Reflection）
    • Type类
    • is运算符
    • as运算符
  • unsafe上下文
• C# 2.0 —— 追赶 + 创新
  • 泛型（Generic）
    • 泛型约束
    • 泛型方法的泛型类型的自动推断
  • 分部类型（Partial Type）
  • 匿名方法（Anonymous Method）
    • 强类型委托（Strongly Typed Delegate）
  • 可null值类型（Nullable）
    • 可null值类型的类型判断
  • 迭代器（Iterator）
  • C# 2.0的其他改进
• C# 3.0 —— 分道扬镳、放飞自我、跨时代创新
  • 自动属性（Auto-Implemented Property）
  • 隐式类型（Implicitly Typed）
  • 初始化器（Initailizer）
  • 匿名类型（Anonymous Type）
    • 匿名类型的属性名称推断
  • Lambda表达式
  • 分部方法（Partial Method）
  • 扩展方法（Extension Method）
  • 表达式树（Expression Tree）
    • 生成、编译和执行表达式树
    • Expression和代码分析
    • 生成表达式树的一个情景化的例子
  • LINQ
    • 查询表达式（Query Expression）
    • 查询扩展方法（Query Extension Method）
      • 针对IEnumerable的查询扩展方法
      • 针对IQuerayable的查询扩展方法
• C# 4.0 —— 独立发展
  • 动态类型（Dynamic Type）
  • 命名参数（Named Argument）
    • 可选参数（Optional Argument）
  • 协变（Covariant）、逆变（Contravariant）
• C# 5.0 —— 字数越少，事儿就越大
  • 调用者信息（Caller Information）
  • 异步编程（Asynchronous Programming）
    • 为什么要用异步
    • 如何理解异步和线程的关系
    • Task、Task和异步方法
    • 使用新线程启动任务
    • 等待多个任务
    • 异步的优势
    • 异步的死锁（deadlock）问题
    • 异步的Java对照
• C# 6.0 —— 语法糖机枪
  • 异常筛选器
  • 属性初始化表达式
  • null传播运算符
  • 字符串内插（String Interpolation）
  • nameof运算符
  • 索引初始化表达式
  • C# 6.0的其他改进
• C# 7.0—— Python是个好东西
  • out变量声明
  • 元组（Tuple Type）
    • 元组的赋值
    • 元组的解构（Deconstruction）
    • 自定义类的解构方法
    • 何时使用元组
  • C# 7.0的模式匹配（Pattern Matching）
    • 常量模式
    • 声明模式
    • var模式
    • case的when子句
  • 本地函数（Local Function）
  • 表达式主体（Expression-Bodied Member）
  • ref返回值、ref局部变量
  • 弃元（Discard）
  • throw表达式
  • 更多的可等待类型
    • 异步方法构建器
  • C# 7.0的其他改进
• C# 7.1、7.2、7.3 —— 小碎步
  • C# 7.1的改进
  • C# 7.2的改进
    • in参数、readonly struct、ref struct、ref readonly返回值、ref readonly struct
    • Span、ReadOnlySpan
    • 新增了几种泛型约束类型
    • 命名参数不必跟在尾部
    • C# 7.2的其他改进
  • C# 7.3的改进
    • 元组的==和!=支持
    • 针对out变量声明的改进
    • stackalloc初始化器
    • 特性可作用于自动属性的字段
    • 含in参数的方法的改进
    • C# 7.3的其他改进
• C# 8.0 —— 当语法升级成为日常
  • readonly成员
  • 接口的默认实现
  • C# 8.0的模式匹配
    • switch表达式
    • 弃元模式
    • 属性模式
    • 元组模式
    • 位置模式
  • using声明
  • 可null引用类型
  • 异步迭代器
  • 异步可释放
  • 索引（Index）、范围（Range）
    • 索引定位
    • 范围切片
    • 自定义类型支持索引和范围
      • 显式支持Index和Range
      • 隐式支持Index和Range
  • null合并赋值运算符
  • C# 8.0的其他改进
• C# 9.0 —— 新的征程
  • init访问器
  • 记录（Record）
    • 记录的继承
    • 记录与struct比较
    • with表达式
  • 顶级语句
  • C# 9.0的模式匹配
    • 类型模式
    • 关系模式
    • 逻辑模式
    • 模式匹配的总结
  • 目标类型new表达式
  • 协变返回类型
  • Lambda的弃元参数
  • 模块的初始化方法
  • 条件表达式的目标类型优化
  • C# 9.0的其他改进
• C# 10.0 —— 学无止尽
  • 记录结构（Record Struct）
  • 属性模式的改进
  • Lambda表达式的改进
  • const可以使用字符串内插
  • 元组解构声明的优化
  • 调用者信息改进
  • C# 10.0的其他改进
• 相顾回眸
  • 有什么是Java有但是C#没有的
  • C# Style
    • 怎样看起来像一个原生的CShaper
• 附录
  • 参考资料
  • 作者按

正文之前

基本概念

这里列出C#和.Net的一些基本概念，供参考：

C#

• C#是一门语言，他的语法类似C++和Java。
• C#是完全面向对象的语言，程序入口点也在类中（Main方法）。
• C#用于编写.Net程序，但不是唯一的选择。除了C#之外，还有F#、VB.Net等等语言，也可用于编写.Net程序。

.Net

下面是一些和.Net有关的名词。（名词解释中出现的英文缩写，也会在列表中找到相关解释。）

• .Net，是一套框架，它主要由CLR和FCL组成。因为.Net程序不仅仅支持一种语言编写，所以下面的各条术语都有前缀Common。Common翻译为公共，体现的是跨语言、通用。

• CLR（公共运行时，Common Language Runtime），是CLI的具体实现，并且也是目前为止的唯一实现。它包含JIT编译器等组件。CLR有很多，包括.NetFramework，.NetCore，Mono.Net，以及最新的.Net等。

  CLR相当于Java的JVM。CLR与JVM的最主要区别在于：CLR被设计为与语言无关，而JVM被设计为特定于Java。

• CLI（公共语言基础设施，Common Language Infrastructure），是微软公司向ECMA提交的一份语言和数据格式规范。包括CTS、CIL等。CLR实现了该规范。

• CTS（公共类型系统，Common Types System），定义了能够在CLR上运行的语言规范。它定义了通用的数据类型。

• CIL（公共中间语言，Common Intermediate Language，或简称IL），是一种中间代码，是.NET框架的低阶人类可读语言，且与开发时所用的上层语言无关。上层的语言，如C#等，会在生成dll和exe时被编译器编译为CIL代码，而非直接编译为机器码。这种代码与底层硬件设施无关，可以由CLR中的JIT编译器翻译为机器语言执行。由于这样的设计，使得不同上层语言调用其他语言编写的库时，不会遇到障碍。

  CIL对应Java的字节码。

• JIT编译器（即时编译，Just-In-Time Compilation），是CLR的重要组成部分。用于将CIL代码翻译成机器码。JIT编译器在运行时（Runtime）工作。在IL代码第一次被执行时，会按照具体的CPU类型、操作系统类型等将IL翻译成机器码并执行。JIT对同一段IL代码的编译只会执行一次，第二次以后执行便会直接使用机器码，不再执行编译过程，以优化效率。

• 托管代码（Managed Code）和非托管代码（Unmanaged Code）：托管代码为可由编译器编译为CIL的代码。正常情况下我们编写的C#代码都是托管代码。调用其他非.Net语言（如C++）编写的库，或使用unsafe上下文编写含指针操作的代码，属于非托管代码。托管代码是内存安全的，对已分配的内存空间由GC进行管理。

• GC（垃圾回收器，Garbage Collector），它通过对象引用计数器管理对象的引用情况，并在对象失去所有引用后执行自动的内存回收工作，因而不必像C++一样手动free掉分配的内存空间。GC是所有高级语言中非常重要的内存管理机制。

• FCL（框架类库，Framework Class Library），与CLR并列，是.Net的重要促成部分。大家都明白，语言和语法只是一方面，真正要完成具体任务，离不开各种类库的帮助。而.Net提供了大量官方的类库，功能强大，且覆盖极广。从前，CShaper有时倾向于选择官方类库而非第三方类库，很大程度上也是由于官方类库过于强大而培养出来的习惯，算是一种思维定式（俗称：微软大法好）。当然，随着.Net本身的走向开放，CShaper们的心态现在也很开放了。因而github上C#的优秀开源项目也越来越多。FCL具体又可以划分为BCL和AppModel。

• BCL（基础类库，Basic Class Library），.Net较为底层的类库，与应用类型无关。基础类库可用于各种类型的开发场景中。

• AppModel，是.Net官方类库中，用于决定应用形态的框架性类库。包括 WCF、WPF、WinForm、Webform、ASP.NET MVC、ASP.NET Core等等等等。例如：WCF用于编写服务，并以各种方式（终结点）暴露服务（几乎已经淘汰）；WPF、Winform用于编写窗体应用；ASP.NET系列用于编写Web应用等。

  可以类比Java的SpringBoot，SpringMVC等。不同点是.Net的这部分库都是官方的，而非第三方提供。

• Debug模式和Release模式：在编译时可以选择Debug和Release模式。

  • Debug模式一般用于调试，这种模式会在生成的CIL中插入大量调试符号（Debugging Symbols）。Debug模式下生成的CIL代码依然具有较高可读性。它保留了源码中的代码所处类型、方法、行号等信息，并且可以准确的捕捉和定位异常。Debug模式不会对代码做编译器优化，也不会调整代码执行顺序。表现为程序完全按照书写内容执行。例如：给一个从未被使用过的临时变量赋值常量值，Debug模式的程序会照做。
  • Release模式，用于生产。是程序执行发布（Publish）操作时默认的模式。Release模式打出来的应用程序集文件（dll、exe）要比Debug模式小的多。Release模式会对代码做编译器优化，例如将数个简单赋值语句合并成一句等等。因而可能会丢失原始的代码行号等信息。在IDE中使用Release模式运行调试时，可能无法准确命中断点，也有可能无法准确捕获未被catch的异常。Release模式下，使用Reflector等工具进行反编译，会发现有些代码变得跟原始代码有差异，这包括但不限于本地变量名被抹除、语句顺序调整等。因而，调用第三方发行版包时，很难通过反编译进行包内方法的调试。

• Module(模块，或Managed Module，托管模块)。是编译后的一个代码单元，是Assembly的组成部分。一个模块主要包含元数据和IL代码。元数据主要是两部分组成：一部分是模块中所定义的所有类型描述、方法所在位置等信息；另一部分是所引用并且使用到的其他库中类型的描述，这部分信息使得JIT可以在运行时加载这些类库，而不用预先将所引用的库也编译进模块中。IL则是由JIT编译并执行的代码。注意：模块与命名空间之间没有必然连系。

• Assembly(应用程序集)，是.Net程序的组成单元，也是版本控制的最小单元。它由一个或多个模块、资源定义文件（Manifest）、资源文件组组成。资源定义文件包含CLR版本信息、应用形态信息、程序入口点位置等。资源文件组可包含一堆被打包进Assembly的资源文件，甚至可以包含dll。Assembly一般被打包为独立的dll（类库）或者exe（含入口点的程序）文件。.Net的程序正常情况下不会把不同的dll、exe打包成独立文件，一个完整功能的.Net程序大都由多个exe和dll文件组成，他们通过引用关联起来。常见的例如：由一个exe文件作为入口点，在该exe中调用了其他的多个dll文件中的功能，它们共同组成了一个完整功能的.Net程序。这里的每个exe或dll文件都是一个应用程序集。应用程序集是自描述的，因而只需要引用dll文件即可使用，不像C++等可能还需要.def、.h文件的配合，也不像Com组件那样需要配合注册表使用。应用程序集采用使用时加载的策略：代码中引用了某个dll，在Runtime实际使用该dll中的任何类或定义之前，应用程序集并不会被实际加载。应用程序集既支持在项目中静态引用，以便在编写时提供语法提示和执行编译器检查，并在打包时将被引用的应用程序集类型定义描述写进元数据内；也支持通过Assembly类在运行时动态加载，甚至可以从资源文件中加载。默认情况下，一个项目在编译时会生成一个仅包含一个模块的应用程序集，因而大部分时候项目、模块、应用程序集是一一对应的。但是，你仍然可以通过命令行工具将一个项目、甚至一个代码文件编译成一个模块，然后再使用工具将多个模块拼接在一起，打包成一个应用程序集文件。这样做时，你甚至可以用不同的语言来编写这些模块。注意：应用程序集与命名空间之间也没有必然连系。

  读者可以自行将Assembly和Module，与Java的多Module项目做下类比。

• Nuget：Nuget是.Net的包管理工具。nuget.org也是支持第三方.Net的包发布平台。Nuget很好的解决了版本控制的问题。因为类库的dll文件并不会跟随引用它的应用程序打包进exe，而是保持独立的dll，所以当你的解决方案中，一个项目引用了另一个项目，而这两个项目又都引用了同一个包，但是包的版本却不同时，Nuget可以根据一定的策略保证所引用的包版本最终一致，并在无法调和版本时在编译时便给出报错。添加Nuget的包可以直接通过IDE的Nuget包管理界面，或者通过开发命令行的Install-Package命令，也可以直接修改项目文件（一般为.xxxxproj格式，如C#项目为.csproj）。打包自己开发的程序为Nuget包，可以通过IDE直接进行操作；也可以遵循Nuget包结构构建目录，然后使用Nuget命令行工具、Nuget包管理工具进行打包。使用IDE的自动打包时，如果被打包的项目包含对解决方案内其他项目的引用，则打包成Nuget包后，会自动转换为对Nuget包的引用。

  Nuget类似于Java的Maven。它们的主要差异：

  • Nuget并不区分开发仓库和发布仓库。Nuget包同一版本不支持重复推送，已下载过的包本地会有缓存。因而推到Nuget仓库的包，不便于使用同一个版本号不断更新。对于非稳定版包，一般使用版本号+后缀的形式推送。如：1.0-preview，1.2-rc3.1等。IDE中搜索时，可以过滤这些非稳定版本的包。
  • 而Maven则区分Snapshot仓库和Release仓库。Maven的Snapshot仓库拥有更灵活的策略：同一个版本号的Maven包可以重复推送，而引用该Snapshot版本的包的代码，也会根据Maven仓库的推送，拉取最新的包，而不是使用本地缓存的之前拉取得包。这点上Maven要更为强大。

.Net和C#发展史

C#版本发布时间，及与.Net的对应关系，如下表：

C#版本	.NET版本	发布日期
C# 1.0	.NET Framework 1.0	2002年2月13日
C# 1.1	.NET Framework 1.1	2003年4月24日
C# 2.0	.NET Framework 2.0	2005年11月7日
C# 3.0	.NET Framework 3.0	2007年11月6日
	.NET Framework 3.5	2007年11月19日
C# 4.0	.NET Framework 4.0	2010年4月12日
C# 5.0	.NET Framework 4.5	2012年8月15日
C# 6.0	.NET Framework 4.6	2015年7月20日
	.NET Core 1.0	2016年6月27日
C# 7.0	.NET Framework 4.6.2	2016年8月2日
C# 7.1	.NET Framework 4.7	2017年4月5日
	.NET Core 2.0	2016年8月14日
C# 7.2	.NET Framework 4.7.1	2017年10月17日
C# 7.3	.NET Framework 4.7.2	2018年4月30日
	.NET Core 2.1	2018年5月30日
	.NET Core 2.2	2018年12月4日
C# 8.0	.NET Framework 4.8	2019年4月18日
	.NET Core 3.0	2019年9月23日
	.NET Core 3.1	2019年12月3日
C# 9.0	.NET 5	2020年9月4日
C# 10.0	.NET 6	2021年11月9日

C#和.Net发展，关键节点简要介绍：

1. J++

   • 1995年，由于互联网兴起。Sun公司推出的Java大火。因为其跨平台特点，微软感受到危机。为了将用户留在Windows，微软启动了J++项目。其含义为Java增强版，旨在优化Java开发体验和执行性能。
   • 1997年，Visual Studio 97发布，首次包含J++。
   • 1998年，大名鼎鼎的Visual Studio 6.0发布（对，就是那个曾经大学必学的VS6）。此时的J++，不仅性能比Sun的Java更高，还支持了WindowsAPI。其易用性迅速抢占了Java的市场，成为业内公认的优秀Java编译器。因其只能在Windows下用，也帮助微软占了操作系统市场。
   • 同年，Sun忍无可忍，将微软告上法庭。
   • 官司一直打到2001年。法院最终判定微软未能遵循Java规范，Sun公司胜诉。同年，Sun和微软达成和解：微软停止J++项目，Sun不再追究经济损失。

2. .NetFramework 1.0

   • 微软之所以甘心放弃J++项目，也是因其早就启动了新的项目，用于替代Java。这便是.Net。同时，参考了Java和C++的语法，设计了全新的语言：C#。
   • 2002年，.NetFramework1.0跟随Visual Studio .NET 2002一同发布。此时的.Net支持两种语言:C#和VB.Net。支持VB.Net也是为了让既有的VB开发人员可以快速上手。从此，.Net时代正式开启了。
   • 有个玩笑说：C#的含义，有可能是C++++。从本质上讲，Java和C#都是C++语法系统的。所以，这种说法有可能是真的。

3. C#3.0 和 .NetFramework3.5

   • C#3.0之所以特殊，是因为3.0之前C#主要是模仿Java。而3.0开始，C#正式与老师分道扬镳，开始放飞自我了。
   • 2007年C#3.0跟随Visual Sudio 2008一同发布。这个版本带来了诸多重大更新。它引入了Lambda表达式、表达式树、扩展方法、隐式类型变量、初始化器（Initializer）等等重要机制。同时还引入了LINQ这个重磅炸弹 —— 它被视作CShaper的快乐之源。
   • 到.NetFramework3.5发布，.Net的第一个高度成熟的版本形成了。.Net3.5帮助微软占据了大量市场。

4. C#5.0

   • 2010年.NetFramework4.0（对应C#4.0）正式发布。值得注意的是，.NetFramework3.5和之前的版本一直做了向下兼容。3.5兼容从2.0到3.5的所有版本。但是到了.NetFramework4，这种兼容被打破了。在这之后，3.x和4.x成为两个互不兼容、相互独立的CLR版本。因而，此后很长一段时间内，你的机器上可能要装同时装3.x和4.x两个版本的.NetFramework，才能应对各种.Net应用。
   • 到了C#5.0发布时，正式了引入异步编程。这又是一项跨时代的技术。对js后来的发展也产生了深远的影响。而C#5.0对应的.NetFramework4.5，也成为了继3.5之后第二个高度成熟版本。

5. .Net Standard

   • 由于Linux在服务领域的一骑绝尘，.Net不能跨平台的弊端逐渐显现出来。终于，有人看不惯.Net的不跨平台了。Mono项目不依赖.NetFramework的源码（也没法依赖，.NetFramework并不开源），重新实现了.Net CLR，即跨平台的Mono.Net。再到后来的Unity3D、Xamarin，.Net的第三方实现开始占领市场。
   • 同时，微软自家也在面临多版本问题，首先有互不兼容的3.5和4.5；其次，他们还为不同的系统定制了不同的.Net。比如，他们为移动设备和XBOX定制了阉割版.Net Portable。
   • 经过了漫长的封闭、服务器领域市场的不断衰退和Windows Phone的惨败之后。2014年，微软终于迎来了一位靠谱的CEO。他意识到了开放的重要性，开始积极拥抱开源和跨平台。微软开始积极筹备自家的跨平台.Net。当时还仅仅考虑网站开发，计划命名为Asp.Net MVC 6。后来随着项目的进行，微软改变策略，决心做成一个全面、通用的、跨平台的.Net，并取命.Net Core。
     • 提到这位CEO，不得不吐槽两句。由于他是个印度裔（硅谷已经被印度CEO裔占领了），导致他上任后微软印度裔的开发人员数量大幅上升。因而，我们现在经常能在微软系的软件中，感受到各式各样满满咖喱风味的BUG。
   • .Net CLR的混乱局面由此便形成了。各式各样的CLR，互不兼容。如果想要重用你的代码，只能针对目标版本重新编译。而且，还需要考虑各版本的框架结构和类库、语法支持度问题，难免要针对不同CLR版本做出不同程度的代码修改。在当时，给人印象深刻的一点是：你下载的Nuget包里的lib目录下，会有许多并列的子目录，包括net30、net35、net45、net46、net461、netcoreapp2.2等等等等。每个目录均由相似的文件构成：都包含类库的dll和xml等文件。不同的是每个dll是面向不同的目标CLR编译的。而你自己写的类库，很多时候也不得不编译成各种不同的目标框架版本，以适应不同目标版本CLR的程序。
   • 因此，微软提出了.Net Standard。这是一套标准，而非CLR的实现。其目的是将一众.Net框架统一起来，提高他们的一致性，从而可以共享代码。.Net Standard其实是一套API规范，目标代码的运行需要由各个.Net CLR来具体实现。因而，.Net Standard只能用来编写通用类库，而不能编写有入口的完整程序。使用.Net Standard编译的类库，可以跑在支持.Net Standard的任意.Net实现上，只要CLR支持的.Net Standard版本不低于你的库的目标.Net Standard版本。从而实现了Mono.Net，.NetFramework，.Net Core等不同版本的.Net之间可以共享代码。有趣的是，.Net Standard生成的dll打包进Nuget，也要放到lib目录下的netstandardx.x的子目录里。针对多种目标CLR和针对Standard的dll还是可以并存。
   • .Net Standard是微软的无奈之举。这个尴尬的境地，到.Net5后被使用新的方式彻底破解。

6. .Net Core

   • 2016年，.Net的官方跨平台版本终于来了。.Net Core 1.0正式发布。它不仅跨平台，还是开源的。最早开源于微软自家的开放代码平台CodePlex，后来迁移至微软自家的开放代码平台GitHub。.Net Core的发布标志着微软终于结束了封闭，彻底走向了开放。
   • .Net Core的版本升级策略也发生了转变。跟诸多常见开源项目一样，虽然它仍然会尽量做到向下兼容，但是这已经不再那么重要了。每当新的大版本发布，可能都会从应用程序框架结构上做出些调整。因此，为了升级到新版本，开发者可能需要少量修改代码，而不像之前.NetFramework时代那样仅仅需要改一下版本号。不过对于具体的升级改动，官方也会在文档中给出指南。
   • 随着框架不断完善，2019年底，.Net Core 3.1发布。.Net Core迎来了第一个LTS（Long Term Support，长期支持）版本。
   • .Net的后续发布计划也在此刻确定了。.Net Core 3.1的下一个版本不会是.Net Core 4.0，而是决定后续将.NetFramework和.NetCore合并，不再区分多个版本，并统一命名为.Net。

7. .Net

   • .Net的发布时间表（Time Schedule）确定为：从2020年开始，每年的年末会发布一个大版本的.Net。并且，偶数序号.Net将获得LTS。
   • 因为合并，以后不会再有.Net Framework和.Net Core之分，所以新的.Net CLR更名为.Net。合并后的第一个.Net，实际上就是.Net Core 4.0。但为了避免跟.NetFramework 4混淆，跳过了4.0的命名，直接使用了.Net5。
   • .Net6是.Net合并成单一框架后的第一个LTS版本。也是刚刚发布没多久的版本。它与Visual Studio 2022一同发布。

曾经因为封闭，微软尝到了甜头，封闭的开发、运行环境和封闭的操作系统互相促进，奠定了微软的市场霸权。

但是，同样也是因为封闭，在开源社区大行其道的201x年代，Linux逐渐取代Windows成为服务器首选系统。.Net因为不具备跨平台的能力，也错失先机，被Java抢占了大量市场份额。时至今日，得益于大量优秀的开发者的参与贡献、大量优质开源项目的支撑，如今Java生态要好于.Net。这在国内更甚，互联网大厂中Java占有绝对统治地位。

虽然.Net的开放来的迟了些，但是晚到的总胜过没有。随着优质的开源项目的不断加入，相信.Net还是未来可期的。尤其是在LoT相关领域，在当前还没有哪个语言坐稳垄断地位、局势还不明朗的情况下，它依然还有机会。

.Net正式合并后，之前的这些熟悉的名称，将成为过去时。让我们记住它们最后定格的版本：

• .Net Standard 定格在 2.1
• .Net Framework 定格在 4.8
• .Net Core 定格在 3.1。

.Net 加油。

最后多絮叨两句。封闭的坏处显而易见。微软尝尽了封闭的苦果。反观如今的水果，总觉得似曾相识。诚然，水果在很多方面比微软高明得多，而它的用户的粘性也要强的多。但是，近年来一次又一次霸道专横的骚操作，给消费者带来的冲击，还是在不断消耗它的生命力。历史总是惊人得相似，我们都不希望看到微软式悲剧在水果上再次重演，希望水果能早日收起戾气、拥抱开放，真正尊重消费者，而不是一次次让消费者无语。

本文的重点是语法，而非类库

进入代码之前，还有些话想说：

本文的主题是C#语言，而非.Net的类库。因而大部分篇幅只关注于语法级别的演进。

• 譬如：Task类在.NetFramework 4.0（对应C#4.0）已经引入。但是此时还不支持async/await关键词。因此，此时的Task类仅仅是.Net类库的更新而已，并未引起C#语法的变动。而到了C#5推出（.NetFramework4.5），引入了async/await，才体现在C#语法上。因此，我们不会在C#4.0的章节介绍Task类，而会在C#5.0介绍异步编程。

• 再比如：元组的概念也是.NetFramwork 4.0（对应C#4.0）就有了。但是，它在当时表现为Tuple类，并不支持独特的圆括号语法，也没有支持解构。直到C#7.0引入ValueTuple时，才在产生了C#的新语法。因此，我们也不会在C#4.0时的章节介绍引用类型的元组类，而会在C#7.0的章节介绍值类型的元组的语法。

• 对于特别重要的类库，本文也会用适当篇幅来介绍。比如：LINQ（C#3.0）的实现既有语法层面的（查询表达式），也有类库层面的（查询扩展方法）。因为查询表达式本质上依赖查询扩展方法，又因为这些扩展方法同时使用了C#3.0的扩展方法、表达式树两种语法，加之其在日常开发中的极高使用频率，也会着重做出介绍。

Hello World

下面的程序展示了一个C#程序大体长什么样：

//Program.cs文件：
using System;  //引用命名空间，相当于Java的import
namespace Sample //定义命名空间，相当于Java的定义package
{
    class Program //定义类
    {
        static void Main(string[] args) //定义方法。Main方法是程序的入口点
        {
            Console.WriteLine("Hello World.");  //打印Hello World.到屏幕
        }
    }
}

• 首先，C#是完全面向对象的语言，不存在排除在任何类之外的裸露语句。程序入口点也定义在类里。（C#10.0之前）
• 一般而言，一个程序需要有一个程序入口点，才能执行。程序入口点一般为Program.cs里的Main的方法。

命名空间（Namespace）

C#采用命名空间来组织类，类似于Java的包，但比Java的包更灵活。

与Java的package的主要对比：

• namespace不必跟目录对应，可以随意指定。只要你愿意，你的类可以全部放在System空间下。而Java的包名必须跟目录对应。
• namespace是块结构，由花括号包裹（C#10.0之前）。它在一个文件中任意位置可以出现多次，即一个文件可以包含多个命名空间。而Java的单个文件必须对应单个包名，且包声明必须放在第一句。
• 习惯不同，namespace一般每一段都是大写字母开头，并且没有以com开头的习惯。Java的包名一般全部用小写，且大多数公司的习惯为以com.开头（看各公司要求）。

using语句

using语句，主要用法：

• 直接引用

  using System.IO;
  

• 别名

  using io = System.IO; //给命名空间指定别名
  
  //使用：
  io.FileStream fs;  //使用别名
  

• 静态引用（C#6.0引入）

  using static System.IO.File; //注意：静态引用只能引用类，而非命名空间。
  
  //使用：
  FileStream fs = Open("test.txt", FileMode.Open);  //直接使用File类的静态方法Open，替代File.Open
  

• 释放模式
  using还有一个跟命名空间无关的用法。用于自动释放可释放资源。请参阅using自动释放语句

与Java的import语句对比

• C#的using的目标是命名空间，不能是具体类型（静态引用除外）。直接引用类型会报错。
• Java import的目标是类型。直接import包会报错。但是可以通过包名.*来一次性引入包下所有类型。
• C#的using xxxx;，实际等于Java的import xxxx.*;。

可以通过显式指定命名空间路径，来使用命名空间下的类，即代码中直接使用命名空间.类名。显式引用时，可以不用using。

System.IO.FileStream fs;

---

接下来，我们将进入本文的主题。按照C#版本时间线，一步步介绍C#的语法演化。

C# 1.0 —— Java的替代品

C# 1.0，深度参考了Java，并更多的保留了C++中被Java剔除的特性。同时，针对Java做出了一些改进。因此，C#语法上与Java类似，但是又比Java多了一些语法特性。例如，属性就是一个很好的创新。

C# 1.0，实现了以下功能

类（Class）和结构（Struct）

类和结构是C#代码的基本组成单元。

对比Java，C#的类定义文件也较为灵活：

• C#单个文件中可以定义多个类，且可以任意指定可访问性，支持多个public类，并且类可以分散在不同命名空间中。而Java单个文件只能有一个public的类。
• C#文件名与类名不必相同，而Java文件中public的类必须与文件名一致。

Class与Struct的区别

1. class是引用类型，struct为值类型。class可以为null，struct不可以。class的赋值为复制引用地址，struct的赋值为元素拷贝。
2. class不可以使用Nullable<>类封装。struct可以。简写作 “类型?”(C#2.0引入。8.0之后新增了可null引用类型，这条不再普遍成立)
3. class可以继承，struct不可以，它是密封的(sealed)。关于密封类请查看其他修饰符
4. class如果不显式声明构造器，默认拥有无参构造器，但在声明构造器后，默认构造器会被删除。如果仍需要无参构造器，需要显式声明。结构不可以声明无参构造器（在C#10.0取消了这个限制），它默认拥有无参构造器，并且无法被删除。

修饰符（Modifier）

可访问性修饰符（Access Modifier）

C#支持的可访问修饰符：

• public

• private

• protect

• internal

  • 只能在同一个应用程序集下可见。在编写类库时，internal的类在类库内相当于public，但是对于引用该类库的使用者，它不可见。

• protected internal

  • 相当于protected or internal

• private protected（C#7.2引入）

  • 相当于protected and internal。因为protected internal组合已经用来表示or的关系，而修饰符的顺序是无关紧要的。因而，只得采用这么个蹩脚的关键词组合来指代and的关系。

直观的对比，请看如下表格：

调用方的位置	public	protected	internal	protected internal	private protected	private
在类内	✔️	✔️	✔️	✔️	✔️	✔️
派生类（相同程序集）	✔️	✔️	✔️	✔️	✔️	❌
非派生类（相同程序集）	✔️	✔️	❌	✔️	❌	❌
派生类（不同程序集）	✔️	✔️	✔️	❌	❌	❌
非派生类（不同程序集）	✔️	❌	❌	❌	❌	❌

如果代码中未书写可访问性修饰符，则：

• 对于类，默认的可访问性是internal
• 对于类的成员，默认的可访问性是private
  • 特别的，对于嵌套的类，内部类的默认可访问性也是private

Java没有类似internal的修饰符。

Java的类不书写任何修饰符时，此类会被限制在仅Package内可访问，被称作friendly的（注意friedly并不是关键词）。需要注意，是限制在Package内，而非Module内。从C#角度理解，就是限制在命名空间内可访问。C#也没有这种机制的修饰符。

其他修饰符

• static：静态成员、静态类（C# 2.0引入静态类）

• abstract：抽象类或抽象方法

• sealed：

  • 修饰类，表示密封类。密封类不可被继承。
  • 修饰方法，表示密封的方法，此方法不可再被派生类重写。

• const：定义常量。

  • 注意：值必须是编译时常量（可以在编译阶段计算出结果的表达式）。也就是必须是字面量（Literal），或者由字面量和简单运算符组成的表达式。特别的，string类型因为其不可变性，是可以作为常量的。如果值需要new运算符，则不能定义为常量。这种情况一般用static readonly的组合。

• readonly：用于修饰字段，表示只读字段。是指仅能通过构造方法、字段初始化表达式(C#2.0引入)赋值的字段。该字段在其他位置只读。

• volatile：用于修饰字段，标识一个字段可能会由多个线程同时修改。在多处理器的系统中，对同一块内存区域的读写顺序，有时会为了提升性能而被编译器、运行时甚至硬件重新排列。标记为volatile的字段，可以避免读写顺序被重排，确保完全按照书写的顺序执行。

C#的sealed class对应的是Java的final class（最终类），表示该类不可以被任何类继承。注意：Java 15中也引入了sealed class预览版，并在17时变为正式语法。但是其含义与C#的不同。Java的sealed类的条件更宽松一些：它允许声明的已知的子类继承，除此之外其他的类不可继承。

用于修饰字段时，C#的const和readonly，相当于Java的final。

类型别名

大部分的关键词类型，都是别名：

• int -> System.Int32
• uint -> System.UInt32
• long -> System.Int64
• double -> System.Double
• byte -> System.Byte
• char -> System.Char
• decimal -> System.Decimal
• bool -> System.Boolean
• string -> System.String
• object -> System.Object
• …

特别注意：在C#中上述别名完全等价。

Java中一般大、小写的类型含义并不相同。大写开头的类型是包装类。基本等价于C#中的Nullable（C#2.0引入）。

例如：Java中的Double，相当于C#中的double?。而C#中的Double和double完全等价。

隐式继承、Object类

关于隐式继承，举例说明：enum（枚举）都隐式继承Enum类，delegate（委托）都隐式继承Delegate类，值类型均隐式继承ValueType类，数组都隐式继承Array类。查看这些基类，会发现其定义都是class。但是编译器处理这种隐式继承时，并不会都把它们都变成引用类型，而是按照语法约定确定是值类型还是引用类型。这种隐式继承关系是编译器变的魔术，你无法直接在代码中显式声明这种继承关系。隐式继承的好处是，所有对应类型都可以使用基类定义的方法，如enum都可以使用Enum类定义的HasFlag方法等。

object类是极其特殊的类。C#中的任何类型，都隐式继承自object。任何类型的对象都能与object对象互转。这也包括值类型。

object类定义了ToString、GetType、Equals、GetHashCode等方法。所有类型均可使用这些方法，也可以重写这些方法。

这与Java不同。Java中Object被认为是引用类型的基类，int属于基本类型，不是Object。

值类型 vs 引用类型

值类型举例：

• bool
• char
• int
• 所有struct
• 所有enum
• 元组（C# 7.0）

引用类型举例：

• string
• 数组
• 委托
• 所有class
• record（C# 9.0）

值类型和引用类型特点类似于C++。

• 存储

  • 值类型变量在栈空间中直接存储变量值。对于struct，包含的所有字段都在栈中占用相应大小栈空间。struct中的引用类型字段仅在栈上占用一个指针的大小。当struct嵌套时，占用的空间也会等同于每个struct展开的大小。除了struct之外的值类型和仅包含非引用字段的struct又合称非托管类型（Unmanaged Type），因为它们不会通过GC来回收资源。栈上的空间有着相对固定的回收时机：跟随方法的调用进行压栈和弹栈。这点学过C++的人应该可以理解。非托管类型可以用来与C++等语言编写的库传递参数和结果，也能用于编写unsafe代码。不过由于栈的大小有限，使用过大的struct并不是很好的主意。尤其在多重递归的场景中，使用不当可能快速耗尽栈空间。
  • 引用类型则只在栈内存储堆空间的地址信息，实际数据则存储于托管堆（Managed Heap，以下所提到的堆空间，均指托管堆）空间中。堆的可用空间要大得多，几乎可以使用全部内存。引用类型又叫托管类型（Managed Type），其内存资源通过GC机制回收。

• 赋值和传参

  • 值类型在赋值操作、作为参数传入方法时，会引发数据拷贝。一个struct在赋值时，会拷贝每个字段的值（如果字段本身也是struct，会进一步深拷贝）。对被赋值或传入方法后的变量修改不会影响到原变量。
  • 引用类型的赋值和参数传入只是拷贝地址信息，对被赋值后引用对象的修改都会导致用来赋值的对象的变更。

Java并没有值类型的概念，对应的概念是基本数据类型。基本数据类型包括boolean、float、char、byte、short、int、long共8种。其余均为引用类型。而基本类型全都有对应的包装类。

接下来，我们分别介绍下这两种类型：

值类型（Value Type）

结构

结构（Struct）是值类型的。

除了前面章节提到的不同点之外，结构与类还是很相似的。结构中也可以定义字段、属性、方法等。也正因为如此，我们在C#的教程中，更多提及的是类型（Type）而不是类（Class）。

int、double等关键词类型，是Int32、Double等的别名。通过定义可以看到，它们本质上都是Struct。因而，int等值类型也能够定义自己的方法。加上隐式继承自ValueType和Object。因而int可以使用Equals、ToString等方法；也能使用GetType方法获取Type对象从而使用反射；还可以使用静态方法：如Parse，用于将string转成int。

事实上，Struct可以用于指代一切值类型，包括枚举。

Java没有Struct类型。

Java的基本类型，真的十分“基本”。它们没有成员方法可用。如上例，要将String转成整数，需要用包装类Integer的parseInt方法。

装箱（Boxing）和拆箱（Unboxing）

如果将值类型与object互转，或者与其隐式继承类型互转，会引发装箱（或称为封箱）和拆箱（或称取消装箱）

装箱：

int x = 9;
object y = (object)x;  //引发装箱
ValueType z = (ValueType)x;  //引发装箱
Status status = Status.OK;  //Status是枚举类型
Enum statusBoxing = (Enum)code;  //引发装箱

拆箱

//接上个例子
x = (int)y;  //引发拆箱
x = (int)z;  //引发拆箱
status = (Status)statusBoxing;  //引发拆箱

在装箱前后，调用GetType获取类型描述会得到相同的类型。上例中，x.GetType()和y.GetType()获取到的类型相同，都是Int32；status.GetType()和statusBoxing.GetType()获得到的类型相同，都是Status。

需要注意，装箱和拆箱需要大量计算，因而不是最优选择。如需接收或者传递任意类型参数，应该优先考虑泛型（C#2.0引入），而非使用Object

Java将int赋值给Object对象，也会进行装箱操作。它事实上是将int转成包装类Integer后赋值给Object。装箱后的对象事实上发生了类型变化，原先为int类型，装箱后为Integer。

Java的泛型类型并不允许基本类型。因此，使用泛型时，不会因为可以是基本类型而节省装箱的操作，因此使用Object传递参数和使用泛型类型传递参数相同，并不会导致效率差异。

枚举（Enum）

枚举是值类型的，默认情况下等价于int类型，且可以与int类型显式互转。这点与Java的枚举类不同。C#的enum定义更像C++。

枚举默认从0开始，每项递增。但是你仍然可以指定枚举项对应的值。你还可以只指定一部分枚举项，未指定的枚举项会从上一个指定了值的枚举项顺序递增下来。

枚举允许赋值未在枚举项中列出的int值，作为枚举的值。即：可以将任意整数显式转换成枚举类型，并赋值给该类型对象，不会报错。

枚举的ToString方法，返回的是代码的定义文本。但是如果值对应的项不存在，则ToString直接输出数字。

public enum StatusCode //定义枚举
{
    Success = 0,  //显式指定Success项值为0
    DatabaseError,  //未指定DatabaseError值，因而其值为前一项加1，为1
    SystemError  //同前，此项值为上一项加1，为2
}

//测试
StatusCode code = StatusCode.Success;
Console.WriteLine((int)code); //输出为 0 
Console.WriteLine(code.ToString()); //输出为 Success
code = (StatusCode)100;  //有效赋值，不会报错
Console.WriteLine(code.ToString()); //输出为 100

枚举也可以指定其实现类型。方法是用类似继承的语法，枚举定义时在枚举名后面使用:指明实现类型。实现类型只能是byte、sbyte、short、double、ushort、int、uint、long、ulong这几个整数类型。虽然这里是:符号，但是我们不称之为继承，毕竟Struct本就无法继承，并且枚举既不能重写方法，也无法定义其他方法。

public enum StatusCode : ulong //定义枚举，并指定枚举为ulong类型
{
    Success = 0uL,  //顺便提一嘴：数字后面的L，从规范上来讲要用大写，避免跟1混淆。
    DatabaseError,
    SystemError
}

与Java枚举的对比：

• C#枚举为值类型，等价于int（或其他整数类型）。Java的枚举实际是枚举类，因而是引用类型。
• C#枚举定义仅能列举枚举项，不支持编写成员方法、不能编写构造器，虽然仍能使用object类、ValueType类、Enum类定义的方法，但是却不能重写它们。Java枚举定义实际是定义了枚举类和该类的常量对象。Java的枚举定义中可以插入构造器、方法等，也可以重写toString方法。
• C#的枚举仅能指定实现类型，并且必须为整数类型。Java的枚举虽无法继承类，但是可以实现接口。
• C#枚举可以与int（或者其指定实现类型）直接互转，并且支持将未在枚举中定义的整数值赋值给枚举对象。而Java与int等类型互转，需要通过枚举类定义的字段和get、set方法来实现，并且不存在超出枚举定义项的赋值。
• C#可以给每个枚举项直接指定值，语法为枚举项=值，值为所指定类型，默认是int。而Java必须通过构造器来实现，并在定义枚举项时指定该项如何使用构造器，因而语法是枚举项(构造器参数列表)。
• Java的枚举都有个original方法，它返回的是该枚举项的序号，且固定顺序为0、1、2…。从概念、用法来讲，它并不等同于C#意义上的枚举值。
• 最后又是习惯问题。C#的枚举项一般仍旧按照Pascal规则命名，而Java的枚举项习惯于全大写字母，单词间用下划线连接。

C#和Java的枚举，可以说各有优劣。

• C#的枚举可以直接用来接收数据库、WebApi传入传出参数等中int的值，使其在程序代码内被赋予明确的枚举含义。而Java要把数据库字段转为枚举需要更多额外操作。
• Java的枚举项可以携带更多信息，例如可以同时包含一个int类型的id、一个String类型的name。这在特定场景下十分好用。而C#的枚举只有整数信息，如果要附带其他信息需要通过中文枚举名（为了使用ToString，不推荐）、编写扩展方法（C#3.0）、使用Dictionary映射、封装Struct等手段。

额外To CShaper —— Java的枚举长这样：

//==Java==
public enum StatusCode { //定义枚举
    SUCCESS, DATABASE_ERROR, SYSTEM_ERROR; //枚举项，此处分号可以省略
}

或者：

//==Java==
public enum StatusCode { //定义枚举
    SUCCESS(0), DATABASE_ERROR(1), SYSTEM_ERROR(2); //枚举项，调用构造器。因为下面还有定义内容，此处分号不能省略
    // 成员字段
    private int statusCodeValue;
    // 构造器（注意，枚举的构造器只能是私有的），枚举不可以new，只能使用已定义的项
    private StatusCode(int statusCodeValue) {
      this.statusCodeValue = statusCodeValue;
    }
    //字段值的get方法
    public int getStatusCodeValue() {
        return statusCodeValue;
    }
}

使用

//==Java==
StatusCode code = StatusCode.SUCCESS;
StatusCode cod2 = StatusCode.valueOf("SYSTEM_ERROR");
boolean eq = code == code2;  //因为枚举项是常量，所以==也可以用于判断相等

C#还支持位枚举:

位枚举一般每个枚举项都是2的整次幂。

虽然不是必须，但是定义位枚举时，一般添加FlagsAttribute特性。这样会影响ToString的输出。

位枚举可以方便单个枚举变量同时包含多个枚举项。方法是使用按位与运算符|来合并枚举项。并且可以使用枚举类型内封的HasFlag方法，轻松判断枚举变量是否包含了特定位枚举项：

[Flags]
public enum Operation //定义位枚举
{
    Add = 0x01,
    Modify = 0x02,
    Remove = 0x04,
    Execute = 0x08
}
//...
Operation operation = Operation.Execute | Operation.Add; //赋值位枚举为多个值
Console.WriteLine(operation.ToString());  //输出为 Add, Execute。如果未标记FlagsAttribute，则输出为 9
bool haveRemove = operation.HasFlag(Operation.Remove); //查询位枚举是否包含枚举项

引用类型（Reference Type）

数组（Array）

数组是引用类型的。因而C#的数组与C++不同，它被分配在堆空间上，而不是栈空间上。数组的初始化也使用new关键词。这点与Java一致。

数组隐式继承自Array类，因而Array具有的方法、属性等，数组都可以用。比如Length属性，用于获取数组长度。不过，无法直接使用Array类来声明数组。

//一维数组
int[] t = new int[10];
t[0] = 1;

//二维矩形数组
int[,] a = new int[10,10];
a[0,0] = 1;

//可变长度的二维数组
int [][] b = new int[10][];
b[0] = new int[10];
b[1] = new int[6];
b[0][0] = 1;

与Java不同，C#定义数组时，[]只能放到变量名前面。而Java则既可以放在前面，也可以放在后面。

• byte [] bytes= new byte[100]; //合法
• byte bytes [] = new byte[100]; //不合法

类（Class）

类的继承

C#的继承使用:

Java使用extends关键词

C#不支持多重继承（实现接口数量则不限制），这点与C++不同，但是与Java一致。

嵌套类

类支持嵌套，且嵌套类支持protected、private等修饰符

public class AA
{
    public class BB //public的嵌套类，其他类里可见
    {
    }
    protected class CC //protected的嵌套类，仅其派生类可见
    {
    }
}
public class DD
{
    public AA.BB bb; //ok
    public AA.CC cc; //not ok，编译器报错
}

方法（Method）

方法与函数、过程是同义词，是类或结构的成员，用于描述一段执行过程，并返回或者不返回结果。

C#的命名规范中，方法名以大写开头（即Pascal命名法）

Java编码规范中，方法名是小写字母开头（驼峰命名法）。

方法的参数

out和ref关键词

C#的方法，支持out和ref两个特殊修饰符，来修饰参数。

虽然语法上并不禁止这两个关键词用于引用类型，但是实际上它几乎只被用于值类型。

它们表明，传递参数时，不应复制值，而是传递值变量的引用。

传递为out和ref参数，必须是左值类型的。所谓左值类型，是指可以被放在赋值号=的左侧——也就是说，只能是变量（unsafe模式下还可以是指针取值表达式）。

• out表示输出参数，表明该方法会将此参数作为输出。out参数传入方法前不必赋初始值。对于包含out参数的方法，编译器会检查方法体内每个分支路径，确保每一条分支在return之前都对此参数做了赋值。如果有分支路径没有赋值，会在编译时报出编译错误。这跟检查每个分支路径都有return语句一样。
• ref表示引用参数。方法体内可以对该变量值进行赋值，并实际改变调用时传递得变量的值。ref变量不要求一定要在方法体内更改，也不会做分支路径检查。作为ref参数的变量，在传入方法之前，必须已经赋值。

具有out和ref修饰的参数，在调用方法时，参数前也必须显式添加out和ref关键词

//官方库中int的TryParse方法定义
public struct Int32 
{
    public static bool TryParse(string str, out int outValue);
}
//使用：
int value; //不必赋初值
bool success = int.TryParse("1", out value); //value的值由方法输出
Console.WriteLine(value); //输出为 1

Java不支持上述特性，可以考虑使用自己定义一个类实现包装器的功能，从而变相实现引用传递。注意，无法直接使用官方提供的包装类，因为Integer等包装类内的数据是只读的。

参数默认值

像C++一样，C#支持参数的默认值。

有默认值的参数，在方法调用时可以省略。

public class Class
{
    public List GetStudents(int limit = 20) //limit含默认值20
    {
        //省略
    }
}
//使用：
Class oneClass = new Class();
List students = oneClass.GetStudents(); //可以不指定limit值

Java不支持参数默认值。因而想要实现少传参数的简写形式，只能通过方法重载。

事实上，后续C#还支持了以命名的形式指定参数的值，而对于未指定值的有默认值的参数使用默认值。这个特性被称为可选参数（C# 4.0引入）。而Java语法无法支持此操作。

可变参数

C#使用params关键词标记可变数量的参数

params只能修饰数组类型

//官方库关于string的Format方法的定义
public class String 
{
    public static string Format(stirng format, params object[] args);
}
//使用
string.Format("你好"); //0个可变参数
string.Format("你好，{0}", "帅哥"); //1个可变参数
string.Format("你好，{0}。现在是{1}年。今日天气：{2}。出行建议：{3}。", "帅哥", 2021, "晴", "适合出去浪"); //4个可变参数

Java可变参数的关键词为...。他们在语法上的区别：

1. C#声明可选参数时，需要正常带上[]符号，表示该参数是个数组。而Java，虽然可选参数变量实际为数组类型，但是声明时不带上[]符号。
2. C#的params放在类型前面，而Java的...放在类型后面。

构造器（Constructor）、终结器（Finalizer）

构造方法又叫构造器。类和结构都可以拥有构造器。默认情况下，类和结构都拥有无参数的构造器。类如果主动声明了构造器，则默认的无参构造器会被删除。结构则始终拥有无参构造器。

静态构造器（Static Constructor）

静态构造方法的语法是static 类名() { ... }。它不能拥有可访问性修饰符，不能指定返回类型。并且不能拥有参数。

它会访问类型的任何可访问成员之前被执行。

• 在第一次使用并访问任何静态成员之前
• 实例的构造器被执行之前

它只会执行一次。

public class What
{
    static What()
    {
        Console.WriteLine("作甚");
    }
    
    public What()
    {
        Console.WriteLine("干啥");
    }
}

What what = new What();  //先打印 作甚，再打印 干啥
What what2 = new What(); //只会打印 干啥

注意：仅仅声明What类型的变量what，而不用new初始化，是不会引起静态构造器被调用的。

静态构造器中无法访问非静态成员。

Java的叫做类初始化器（Class Initializer），它的语法是static { ... }。功用完全一致，语法更加简洁。

构造器串联

C#支持本类构造器或者基类构造器的串联，这被称为构造器调用，我们习惯将其形象的称为构造器串联。语法为：构造方法声明之后、方法体之前使用:this(参数列表)或者:base(参数列表)

public class ArtBook : Book
{
    private string Name;
    public ArtBook()
        : base()    //base串联，调用基类构造方法
    {
    }
}
public class NovelBook : Book
{
    private string Name;
    public NovelBook()
        : this("无名")  //this串联，调用本类其他构造方法
    {
    }
    public NovelBook(string name)
    {
        Name = name;
    }
}

Java中的构造器调用使用super();和this();语句，直接在构造方法体内调用。虽然是直接写进方法体内的语句，但规定了只能放在第一句，因此与C#的机理并无不同。对比之下，C#的写法更好的表达了其自然含义。

终结器（Finalizer）

类似于C++，C#支持类的析构方法，又叫终结器。

终结器命名为类名前面加上~

终结器不能加任何修饰符，包括public、private等。

一般不会单独重写终结器。如果类中包含需要释放的资源，一般使用IDisposable释放模式。

多态（Polymorphism）

C#支持的多态包括重载(Overload)、重写(Override，又叫覆盖)和隐藏(Hidding)：

• 重载
  1. 同一个类中，相同方法名，不同参数的方法重载。
  2. 同一个类中，相同方法名，参数也相同，泛型和非泛型的方法重载。（C#2.0以后）
  3. 同一个类中，相同方法名，参数也相同，泛型参数数量不同的泛型的方法重载。（C#2.0以后）
• 重写
  • 父类声明为virtual的虚方法，子类可以通过override关键词进行重写。如果没有标记为虚方法，则子类无法对其进行重写。需要特别注意：必须加上override关键词才是重写，否则就是隐藏，请参考下条。
• 隐藏
  • 任何方法（包括virtual和非virtual的方法），子类都可以对其进行隐藏。使用隐藏语法时，父类的方法没有被覆盖，而是被隐藏了。在调用同名同参方法时，如果调用的对象声明为子类型，则正常调用子类定义的方法；而如果声明为父类型，但实际类型为子类型，则会取消隐藏，调用父类的方法。
    • 隐藏不要求与父类方法拥有一样的访问级别，也不要求其返回类型必须相同。
    • 隐藏一般使用new关键词修饰方法。虽然new可以省略，但是仍强烈建议显式加上new，以提高代码可读性。

下面我们通过举例，看看子类对父类的方法重写和隐藏的区别：

public class Book
{
    public virtual int GetPage() //声明为虚方法
    {
        return 0;
    }
}
public class NovelBook : Book 
{
    public override int GetPage() //重写父类方法
    {
        return 1;
    }
}
public class MathBook : Book
{
    public new int GetPage() //隐藏而不覆盖父类方法，此处关键词new可以省略，但推荐加上
    {
        return 2;
    }
}

然后，我们看看调用：

Book oneBook;

NovelBook novelBook = new NovelBook(); //NovelBook的GetPage方法是重写
oneBook = novelBook;
Console.WriteLine(novelBook.GetPage()); //输出 1
Console.WriteLine(oneBook.GetPage());   //输出 1

MathBook mathBook = new MathBook();  //MathBook的GetPage方法是隐藏
oneBook = mathBook;
Console.WriteLine(mathBook.GetPage());  //输出 2
Console.WriteLine(oneBook.GetPage());   //输出 0

可见：

• 调用重写的方法，会根据调用对象的实际类型，调用其类型的重写方法。子类对象和赋值为子类对象的父类对象，调用的都是子类的方法。上例中，novelBook对象和oneBook对象，调用的都是子类NovelBook定义的方法。
• 调用隐藏的方法，会根据当前对象的声明类型，调用声明类型的方法。此时，子类对象调用的为子类的方法，赋值为子类对象的父类对象调用的是父类的方法。上例中，mathBook对象调用的是MathBook定义的方法，而oneBook对象调用的是Book中定义的方法。

不过，无论重写还是隐藏，其内部均可以使用base.方法来调用基类的方法。

PS：上述重写和隐藏描述的都是非静态的方法。静态方法无法被重写，所以实际上只能被隐藏。

Java没有virtual和override关键词。但是，Java的方法被设计成默认就是虚的。直接在子类中定义对父类方法的重写即可。但也可以通过@Override注解，来标注子类的方法是重写方法。标注此注解同样可以实现编译阶段的检查功能，以确保父类包含此方法。(Java的注解与C#的特性是同义词)

Java没有C#意义上的方法隐藏机制。但是同样可以实现静态方法的隐藏。

属性（Property）

属性，是C#1.0对Java的一个较为明显的优化。

对于Java的类，为了提升可控性，我们一般不会直接将字段标记为public，暴露给外界操作。我们会将字段标记为private、protected，通过暴露public的get和set方法来获取和设置该字段。这样做可以方便进行安全检查、权限控制以及执行额外操作。

例如：

//==Java==
public class Person
{
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}

考虑到get、set模式的通用性，C#提出了一种新的成员类型：属性，用于等价替代上述模式。

上述功能，用属性实现长这样：

public class Person
{
    private string name;
    public string Name
    {
        get { return name; }  //getter
        set { name = value; } //setter
    }
}

上述代码中，Name就是一个string类型的属性。其中，get和set方法被称为访问器。它们又分别被称为getter和setter，实现了与Java中使用get和set方法操作字段一样的功能。

在setter中，可以使用value关键词，来指代要赋值的内容。

由于属性本质上等价于get和set方法，所以可以视作方法。属性可以出现在接口中，也能被子类重写（Override）和隐藏。

从语法上，属性带来了更多便捷。使用属性时，语法形态跟直接使用字段类似：

person.Name = "你好"; //调用setter，给属性赋值
string name = person.Name; //调用getter

需要注意的是，属性需要通过背后的实现字段来进行赋值和获取操作。如果在属性的get、set方法中操作属性本身，可能会引起无限递归。

C#3.0引入了自动实现的属性，自动属性才是属性的最常见定义方式。

对比Java：

• 属性给与了C#更加简洁的语法。既简化了get和set方法的定义，又在使用时避免了Java那样的大量的圆括号，代码更为美观。
• 更为重要的是，属性可以作为表达式的一部分，使得属性可以嵌入到更多场景中。具体说来，在使用属性的setter时（代码表现为赋值表达式），表达式仍具有返回值（即赋值表达式的值）。
• 在后续C#支持的初始化器（C#2.0引入）等语法中，因为有属性的存在，也使得初始化对象时代码简洁不少。这在多重嵌套的情况下尤为明显。而Java虽然有双括号初始化语法，但是一般不建议使用，而且代码也要啰嗦的多。

接口（Interface）

C#的接口习惯于以单个大写字母I作为前缀。而接口的实现类，一般没有固定前后缀。

作为对比，一般Java的接口名无固定前后缀。而接口实现类，习惯加Impl后缀。

接口的实现，语法为类:接口，与类的继承使用相同的符号。

Java则使用了不同的关键词，类的继承为extends，接口的实现为implement。

这里介绍两组比较重要的接口：

可释放接口（IDisposable）

IDisposable指定了Dispose方法，用于释放资源。

using自动释放语句

实现了IDisposable接口的类对象，C#在语法上允许使用using语句自动释放：

using (FileStream fs = File.OpenRead("test.txt"))  //fs会在using块结束后自动调用Dispose方法释放资源
{
    //省略
}

它等价于下面的代码：

FileStream fs = File.OpenRead("test.txt");
try
{
    //省略
}
finally
{
    fs.Dispose();  //释放
}

需要注意，using的括号内是表达式，它返回一个可释放的对象。因而，using并不要求一定要在using的同时声明变量，也可以using已有的对象。

FileStream fs = File.OpenRead("test.txt");
using (fs)   //合法
{
    //省略
}

对于实现了IDisposable的类，如果没有使用using，也没有主动调用Dispose方法。则会在失去所有引用后，于GC回收时被释放。注意，这种情况下具体的释放时机可能变得不可控。如果程序中有循环等大量产生资源的语句，未及时的释放可能引起资源因无法及时回收而快速消耗（例如TCP连接）。

IDisaposable相当于Java的AutoClosable接口

using语句相当于Java的try-with-resources语句。不过，他们也有用法的区别

• C#的using语句，圆括号内为表达式而非语句。因此，using语句的圆括号内只能指定一个对象。如果要同时对多个对象自动释放，需要使用using嵌套。（C#8.0以后支持更为美观的写法，但其本质没有变化）
• Java的try-with-resources，try后面的圆括号为多个声明了可释放资源的语句。因此，可以在一个try语句内一次性同时指定多个资源在块结束后自动释放。
• C#既可以在using括号内同步声明变量，也可以直接使用已声明过的变量。而Java则必须在try括号内同步声明资源（在Java 9之后，不再有此限制）。

在这一点上，Java比C#要更灵活。

To CShaper：Java的自动释放示例

//==Java==
try (
    //同时释放两个资源
    ZipFile zf = new ZipFile(zipPath);
    BufferedWriter writer = Files.newBufferedWriter(outputPath, outputCharset); //最后一个资源后面的分号可以省略
) {
    //省略
} catch (IOException e) {
    e.printStackTrace();
}

IDisposable释放模式

一般在实现IDisposable接口时，不是简单实现Dispose方法，而是会遵循“释放模式”。

释放模式可以在Visual Sudio中自动生成范式代码。它长这样：

public class ChatRoom : IDisposable
{
    private bool disposedValue;

    protected virtual void Dispose(bool disposing)
    {
        if (!disposedValue)
        {
            if (disposing)
            {
                // TODO: 释放托管状态(托管对象)
            }

            // TODO: 释放未托管的资源(未托管的对象)并重写终结器
            // TODO: 将大型字段设置为 null
            disposedValue = true;
        }
    }

    // // TODO: 仅当“Dispose(bool disposing)”拥有用于释放未托管资源的代码时才替代终结器
    // ~ChatRoom()
    // {
    //     // 不要更改此代码。请将清理代码放入“Dispose(bool disposing)”方法中
    //     Dispose(disposing: false);
    // }

    void IDisposable.Dispose()
    {
        // 不要更改此代码。请将清理代码放入“Dispose(bool disposing)”方法中
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }
}

具体来说：

• 在释放模式中，通过一个含布尔参的Dispose方法重载，来实际处理释放资源。接口定义的无参Dispose方法，调用该重载方法，并调用GC方法完成释放。
• 释放模式中，定义了一个标记字段disposedValue，用于避免重复释放。
• 开发者可以根据TODO任务提示，将类中包含的不同类型的资源的释放逻辑写在相应位置。
• 当类中包含未托管资源时，还需要重写终结器。方法是把上述终结器的注释解开即可。

使用释放模式，可以更好的处理托管、非托管资源的释放。

关于非托管资源和非安全上下文，请参考unsafe上下文

枚举器接口（IEnumerator） 和 可枚举接口（IEnumerable）

IEnumerator：枚举器接口，它定义了MoveNext方法、Reset方法和Current属性，用于移动到下一个元素、移动到第一个元素和获取当前元素。IEnumerator也有其泛型版本IEnumerator（C#2.0引入），泛型版本的Current类型不是object而是泛型指定的类型。

IEnumerable：可枚举接口，它定义了GetEnumerator，用于获取该类的IEnumerator对象。IEnumerable也有其泛型版本IEnumerable（C#2.0引入）。泛型类型的GetEnumerator返回类型也是IEnumerator。

实现了IEnumerable（或IEnumerable）接口的类，可以使用foreach语句进行遍历。

foreach语句的关键词为foreach和in：

foreach (object item in list)
{
    //省略
}

我们可以把上述枚举过程叫做迭代（Iterate、Iterating）。但是一定一定要注意，它与迭代器（C#2.0引入）不是一回事，后者在C#中特指迭代器方法（Iterator Method）。

特别的：定义了返回类型为IEnumerator且名称为GetEnumerator的方法的类，即使未指明实现IEnumerable接口，也可以使用foreach。这个特点在C#9.0时被强化：GetEnumerator即使是扩展方法也可以使用foreach。（泛型版本同理）

IEnumerator和IEnumerable（及它们的泛型版本）非常重要，因为它们：

• 可以用来实现迭代器方法（C#2.0引入），这是一个非常重要的机制。
• 可以支持LINQ（C#3.0引入，且LINQ建立在迭代器之上）。LINQ可以算得上CShaper的快乐源泉。

这两个接口都应该优先使用泛型版本（C#2.0）。

C#的枚举器相当于Java的迭代器（Iterator），Java使用迭代器遍历的foreach语法为for (object item : list)。

C#在2.0版本引入了迭代器，但是它与Java的迭代器是两种不同的概念。C#的迭代器是独有的特色语法，它通过编译器进行语序重排，因而具有延迟执行、执行顺序反常识的特点。

委托（Delegate）

委托类似于C++的函数指针，用于指代方法。委托跟类一样，是一种类型定义。

声明委托时定义了一种类型，这个类型规定该委托类型的对象所指代的方法必须满足的参数列表和返回类型。

委托使用delegate关键词声明。

public delegate int Compare(int a, int b); 

上述代码定义了一个委托类型Compare，该委托类型描述了一种需要两个int类型参数，且返回int类型值的方法。

假设，我们有一个方法定义，如下

//接上例
public int CompareMethod(int left, int right)
{
    return left - right;
}

我们看到，该方法的参数数量、每个参数的类型、返回值类型都与Compare这个委托类型的定义相同。这种情况下，定义一个Compare类型的委托变量compare，可以通过赋值使得compare指代CompareMethod方法：

//接上例
Compare compare;
compare = CompareMethod;

这时我们称，compare将实现委托给了CompareMethod方法；CompareMethod是被compare委托的方法，或者说CompareMethod是compare的委托实现。

赋值运算符的右侧，可以是方法名、匿名方法实现或者另一个委托对象。

这里需要注意，赋值方法给委托时，需要满足静态方法、实例方法的要求：在静态方法中，无法给委托变量、静态成员赋值为非静态的方法。

如果赋值给委托的方法在另一个类中，则可以使用对象.方法名或者类名.方法名赋值，具体用法也同样需要满足上一条的要求。

//接上例
Compare compare2 = compare;  //将委托赋值给另一个委托

同时，我们也注意到：在上面例子中，委托规定的参数名和所指代的方法所定义的参数名并不相同。这种情况下仍然可以用委托指代该方法。由此可见，方法要赋值给委托时，参数的名称并不重要。这同方法签名是一致的。

如上声明过后，就可以使用该委托对象，进行方法调用了：

//接上例
int result1 = compare(1, 2);         //第一种调用方式
int result2 = compare.Invoke(4, 2);  //第二种调用方式

上述代码实际调用了被委托的CompareMethod方法。

这里特别提一下，没准你可能会对下里面的语法感到新鲜，但是其实它很好理解：

//接上例
int result3 = someObject.GetCompareDelegate()(3, 7);  //someObject的GetCompareDelegate返回了Compare类型的委托对象。此处在拿到委托对象后立即调用，因而出现连续两个()

使用委托的好处是：可以先声明方法的规格，专心于使用者代码的书写。而该方法规格具体的实现，则可以在运行时再绑定到具体的方法。

注意，委托也是引用类型的，可以为null。

许多语言都有委托机制。如：用于编写IOS程序的Object-C语言，也有委托机制，被称为协议（protocol）。JS就更不用说了，var func = function(){}大伙都写过吧。

Java中没有委托类型。如果要在Java中实现类似委托的效果，需要利用反射。

这里提供一种可行的实现方法：

• 定义一个方法。该方法接收三个参数：一个Object参数，作为提供被委托方法的对象，定义为obj；一个字符串参数，用于提供被委托的方法名，定义为methodName；一个Object类型的数组、Map或者可变参数，用于提供调用该方法时的参数列表，定义为args。
• 实现此方法：先通过反射找到obj对象的、名称为methodName的方法，然后调用这个方法，并将args作为参数传入。

因为Java没有语法层面的支持，上述套路虽然也能够实现类似功能，但显然，这不够优美。

多播委托（Multicast Delegate）

事实上，我们定义的委托类型，属于多播委托（多路广播委托，MulticastDelegate）。对于被委托的方法、委托对象，是可以组合起来的。这被称为委托组合（Delegate Combination）：

Compare compare; //定义委托变量
compare = CompareMethod1 + CompareMethod2; //委托给CompareMethod1和CompareMethod2的组合

+运算符两侧的操作数，同样可以是方法名、匿名的方法实现、委托对象等。它用于组合两个符合同一个委托定义的操作数。如果其中包含null，则仅仅返回另一个操作数（也可能是null）。上述例子中，委托对象compare将委托给两个方法CompareMethod1、CompareMethod2共同处理。执行的顺序会按照从左到右的顺序。

如果要删除一个委托实现，则使用-运算符。

事实上，除了+和-，我们同样可以使用+=和-=运算符。因而我们还可以这样使用委托：

Compare compare; //定义委托变量
compare = CompareMethod1; 
compare += CompareMethod2;

有趣的是，委托对象即使为null，也可以使用+=：

Compare compare = null; 
compare += CompareMethod1; 

Java中如果要实现多播委托，需要记录一组被委托对象，并在委托调用时遍历所有对象，通过反射挨个调用这些对象的指定方法。具体实现我就不举例了。读者可自行思考。（或者问度娘）

事件（Event）

事件是C#引入的一种机制，它的自然含义为回调：当有事件发生时，订阅该事件的类会接到回调通知，并允许订阅者执行额外的处理过程。

C#中的事件是基于委托的。有了委托，才有事件。

与属性一样，事件是类的成员。

事件是一种特殊的委托类型成员。

这句话有三重含义：

1. 委托是类型定义范畴的，而事件是类成员声明范畴的。
2. 事件是委托类型的。
3. 事件是比较特殊的委托成员，它一般为EventHandler类型或EventHandler(C# 2.0引入)类型。

为了给事件赋予自然含义，我们给对事件委托的操作起了更利于人类理解的别名：我们把对事件的=、+=操作称为订阅、添加订阅、绑定回调；对事件委托的调用，称为触发事件、下发事件通知、回调给订阅者。

事件利用了委托的特点，采用后期绑定机制。声明了某个事件的类，本身不必提供该事件的实现。它可以放心的预先编写代码，并在合适的时机触发该事件。

事件还利用了委托的多播性质，允许不止一个订阅者订阅该事件。即：单个事件委托可以提供多个实现方法。事件被触发时，多个实现方法会被依次调用。

事件的典型的应用场景有：某个按钮被点击、设备连接的连上与断开、收到有人给你发的消息等等。

如何声明事件：

• 只能用作类的成员
• 添加event关键词
• 该成员的类型必须是一种委托类型

例如：

public event EventHandler OnConnected; //声明OnConnected事件

上述例子中，定义了一个名为OnConnected的事件。该事件用于在设备建立连接时，向事件的订阅者发起回调。

我们来查看EventHandler的定义：

public delegate void EventHandler(object sender, EventArgs e);

可见，EventHandler是一个委托类型。它描述了一个没有返回值，包含两个参数的方法。两个参数中，第一个object类型的参数，为引发该事件的对象；第二个EventArgs类型的参数，为引发该事件时的额外参数。

虽然任何委托类型都可以用于定义事件，但是一般而言，事件是EventHandler类型或者EventHandler(C#2.0)类型的。

EventHandler作为泛型版本，被更多的使用。其中，泛型参数TEventArgs的约束条件（C#2.0，泛型约束）为：必须是EventArgs类的子类。我们看到EventArgs类事实上是一个空类，不包含任何成员。通常我们会继承EventArgs类，并使用泛型参数为该派生类的泛型版本的EventHandler<子类>来声明事件，以便在事件触发时使用该派生类传递额外参数。

回到上面的例子。声明OnConnected事件后，在编写类库的时候，可以在设备连接成功的时候触发该事件，通知到所有订阅者：

//代码运行到此处，已经成功连接了设备
if (OnConnected != null)
{
    OnConnected(this, EventArgs.Empty);
}

在声明了事件的类中，一般不必提供此事件委托的具体实现。

而对于该类的使用者 —— 一般为其他类，在创建了该类的对象后，可以给该事件添加实现方法，从而实现对事件的订阅。接上例：

Device device = new Device("SomeID"); //声明设备类的对象，该类定义了OnConnected事件
device.OnConnected += ConnectedMethod;  //ConnectedMethod是一个符合EventHandler委托定义的方法
device.Open(); //调用Open方法后，设备会开始建立连接。在建立成功时，将引发OnConnected事件。此时，此处指定的ConnectedMethod方法就会被调用。

由于委托即使为null也可以使用+=运算符，因而事件的订阅者不必确定自己是否为第一个订阅该事件的。实际上，由于使用=运算符会覆盖所有的其他订阅，因而一般不推荐使用=进行绑定回调的操作。

事件也具有访问器，并且可以重写访问器。但是注意，事件与属性不同，它不具备get和set访问器。取而代之的是，它拥有add和remove访问器。

重写add和remove访问器，使用这种形式的定义：

private EventHandler onConnected; //事件背后的实现字段
public event EventHandler OnConnected  //定义事件，并重写访问器
{
    add { onConnected += value; }
    remove { onConnected -= value; }
}

在add和remove访问器内都可以使用value关键词。

同属性一样，重写了访问器的事件，也需要背后的实现字段支撑。访问器内直接调用事件的访问器也可能引发无限递归。

另外一点，一旦你重写了add、remove访问器，事件本身便只能被放在+=和-=的左侧了，甚至无法放在=的左侧。而如果需要调用（触发）事件，只能通过背后的委托类型的实现字段来操作。

因为没有委托的概念，Java同样也没有事件的语法概念。可以参考前面例子中实现多播委托的方式实现事件。

运算符（Operator）

这里仅仅列出一些C#独特的运算符语法

特色运算符

@符号

@符号的两个用途：

1. 可以作为变量的名称前缀。可以用来解决变量名与系统关键词冲突的问题。

   注意：@不被视作变量名称的一部分。例如，使用nameof运算符（C#6.0引入）计算变量名称时，或者做对变量做JSON序列化时，@for都会被视为名称为for。

2. @作为字符串常量的前缀，表示非转义字符串。

   非转义字符串（或称原义字符串），不会转义\符号，也支持在字串内换行。@字符串仅仅会转义两个双引号 —— ""。

   string originString = @"Dear 大家:
       欢迎来到""C#的世界""
   请查看样例：D:\Sample\";
   Console.WriteLine(originString);
   //输出结果为：
   //Dear 大家:
   //    欢迎来到"C#的世界"
   //请查看样例：D:\Sample\
   

   这与Java在12版本引入的文本块有些类似，文本块使用三个连续的"包裹，中间可以换行。这明显是参考了python的语法。不过文本块并不像python那样支持内插。C#也要到C#6.0以后才支持字符串内插。

default运算符

default运算符可以用于计算任意类型的默认值：

int a = default(int);  //结果为 0
string b = default(string);  //结果为 null

default作用于值类型，返回该值类型的0值（例如：int为0，bool为false）；作用于引用类型，返回null。

default运算符作用于struct类型时，将得到所有字段均为default值的该结构类型对象。struct包含嵌套时，每一层struct也都会如此。

default运算符，也可以作用于接口。它将返回null。

default运算符，在给泛型类型赋初值时十分有用。在泛型类型为值类型和引用类型时可获取到不同的默认值。（C#2.0）

C#7.1之后，支持default文本，可以自动进行类型推断。

因为Java的泛型类型不能是int、boolean等基本类型，因而Java的泛型对象并不存在默认值不同的情况（因为泛型对象一定可null，所以默认值必然为null）。因此，Java没有，也没必要有default运算符。

null判断运算符

??是一个二元运算符，左值必须为可null类型

它的含义为：

1. 左值如果为null，则表达式返回右侧的值
2. 左值如果不为null，则表达式返回左侧的值

注意，左侧类型需为右值类型的协变类型、或者可隐式转换为的类型。表达式返回的类型为左值的类型。

int? a = null; //Nullable类型，C#2.0引入
int? b = a ?? 1;  //b的值为1

运算符的特色语法

相较于Java，C#有以下特色语法：

索引器（Indexer）

C#允许开发者，使用类似访问数组的方式，来访问对象内的元素

索引器的定义，如下形式：

public class SomeList
{
    object[] objs = new object[100];
    public object this[int index] 
    {
        get { return objs[index]; }
        set { objs[index] = value; }
    }
}

其中，this[]是索引器定义的关键语法。

索引器内必须要指定getter和setter。

上述例子定义了一个使用单个int类型的索引键（key）、数据类型为object的索引器。其中，索引键的数量可以是多个，使用语法与使用多维矩阵数组相同。

一个类支持同时定义多个索引器。不同的key数量，或者不同的key类型，视作不同索引器，可以并存。

定义了索引器之后，就可以像使用数组一样，使用索引器来操作对象：

SomeList someList = new SomeList();  //这里假设someList已经包含了一些元素
object firstItem = someList[0];  //调用索引器的getter，获取元素
someList[0] = new object();      //调用索引器setter，设置元素

对于了实现多种索引器的类，多种索引器可以同时使用：

SomeCollection someCollection = new SomeCollection();   //这里假设someCollection已经包含了一些元素
string item0 = somecollection[0]; //索引键为int类型，数据类型为string的索引器
bool itemA = someCollection["a"]; //索引键为string类型，数据类型为bool的索引器
somecollection['c', 1.0] = 7;     //索引键为char和float类型，数据类型为int的索引器

从功能上讲，索引器与Java的List等接口的get，set方法作用相同。因为有索引器语法，且C#的List、Dictionary等系统类均实现了索引器，在使用List、Dictionary等列表、集合类型获取和设置元素时，可以使用更简洁的语法，提高代码美观度。而在初始化器（C#2.0引入）和索引初始化表达式（C#6.0引入）语法中，这种代码表现力的差异更加明显。

运算符重载（Operator Overloading）

跟C++一样，C#允许类对运算符进行重载

可重载的运算符有：

• +, -, !, ~, ++, --, true, false 等一元运算符
• +, -, *, /, %, |, &, ^, <<, >> 等二元运算符
• ==, !=, <, >, <=, >= 等二元比较运算符

不可重载的运算符：

• &&和||作为关系运算符，不可以重载。
• 合并赋值运算符：+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=，不可被重载。
• ^x, x=y, x.y, x?.y, c?t:f, x??y, x??=y, x..y, x->y, =>, f(x), as, await, checked, unchecked, default, delegate, is, nameof, new, sizeof, stackalloc, switch, typeof, with这些运算符不能被重载。

运算符重载方法，必须满足以下条件：

• 必须是static方法
• 方法名为operator关键词后面跟上运算符（可以有空格）
• 不能返回void
• 参数个数必须与原运算符的参数个数相同，即一元运算符参数只能是1个，二元运算符参数只能是2个
• 参数中，至少有一个是本类的类型
• 如果重载了==，则必须也重载!=；同理<和>也必须一起重载，<=和>=也必须一起重载。否则编译器会报错。

重载运算符的返回类型，不必是本类类型。

另外，这里有一个有趣的细节：true和false的operator也是可以重载的。配合比较运算符的重载（事实上比较运算符也可以返回非bool类型）。可以让类型进行逻辑运算。但是，除非你是用作科学运算，并且有明确的数学工具作为支撑，否则非常不建议这么干，这会降低代码可读性。

在重载==时，一般建议同步重写Equals方法，以便符合一致性要求。如果重载==而不重写Equals方法，编译器会给出警告，但不是报错。

运算符的重载特性，是大多数开发者在最初对比Java和C#时，最快感受到的语法差异冲击。

以两个例子来看看，运算符重载带来的酣畅淋漓的好处：

string的==

系统类库已经对string类做了==运算符的重载。因此，在C#中，使用str1 == str2来判断字符串相等时没有任何问题的。这也符合大多数语言的语义习惯。

作为C#开发者，首次接触Java时，非常容易犯的错误就是用==来判断字符串相等。因为Java中对于引用类型，==事实上仅仅判断了两个引用对象是否指向同一块内存区域。在Java中，只能用equals方法进行字符串相等判断。这也是许多CShaper刚刚转Java时，吐槽最多的地方。

DateTime的+、-、>、<、>=、<=

两个DateTime对象相减，可以得到一个TimeSpan类型的对象，该对象表示度过了多长时间。

DateTime对象+或者-一个TimeSpan对象，可以得到一个新的DateTime对象，为加减时间差之后的时间。

两个DateTime对象可以直接通过>、<、>=、<=等来比较先后。

DateTime now = DateTime.Now;  
DateTime timeSince = new DateTime(2021, 12, 24, 18, 0, 0);  
TimeSpan ts = now - timeSince;  //获取时间差
Console.WriteLine(ts.TotalSeconds); //打印度过了多少秒，包含小数

TimeSpan addOneDay = new TimeSpan(1, 0, 0, 0); //一天后
DateTime tomorrowSameTime = now + addOneDay;  //加上1天
Console.WriteLine(tomorrowSameTime.ToString("yyyy-MM-dd HH:mm-ss")); //打印明天的这个时间

bool isBefore = tomorrowSameTime < now;  //使用<号比较时间先后

PS: 事实上，现在的项目中，大多用DateTimeOffset结构来替代DateTime。DateTimeOffset拥有更强的时区控制，可以避免一些因为时区导致的问题。

Java要实现时间的加减法，大体有三种方式：

• 使用Date类时，仅靠Date类不够，还必须使用Calendar类。Calendar类在调用方法进行时间加减时，其表达方法相当反人类，你无法只调用一个方法就将时间增加1天零3小时21分7秒。
• 使用时间戳，对时间戳直接计算。显然，这也不够humanity。
• 使用java.time包下面的类，例如LocalDateTime。该包下面的类相对人性化一点。但是它的加减计算仍然需要通过方法调用。由于语言的机制无法支持+/-运算符。

综上，通过运算符重载，可以书写出更贴近自然语言的代码。从而使得代码更加易于理解，更有利于维护。

自定义类型转换（User-Defined Conversion Operator）

自定义类型转换，也是很好用的语法。是省事儿的利器。

先看下系统默认的类型转换：

int x = 0;
double y = x;  //隐式类型转换
double z = (double)x;  //显式类型转换

而对于自定义的类，C#也允许开发者定义自定义的类型转换

类型转换方法的定义形如：

public static implicit operator SomeClass(byte byteValue) { ... }  //隐式类型转换
public static explicit operator int(SomeClass someClassObject) { ... }  //显式类型转换

类型转换方法需要满足以下条件：

• 必须是static方法
• 必须指定是隐式（implicit）还是显式（explicit）
• 包含opertaor关键词
• operetor关键词后面跟要转换返回的类型名称，该方法不必像其他方法一样声明返回类型，方法名称就是返回类型。
• 参数只能有一个
• 参数或者方法名（即返回类型）中，至少有一个是本类类型

注意：

• 作为方法名兼返回类型，别名与完整名称是等效的。以下三者是同一个类型转换方法：
  • public static implicit operator int(MyClass obj)
  • public static implicit operator Int32(MyClass obj)
  • public static implicit operator System.Int32(MyClass obj)
• 从一个类型到另一个类型的转换，只能指定隐式的或者显式其中之一，不能同时声明两者，会冲突。

下面我们来举个常见的应用场景作为例子。

考虑常见的Result类:

public class Result
{
    public int Code { get; set; }  //此处写法为自动属性，C#2.0会讲到。且此处用枚举会更好。这里仅作示例
    public string Message{ get; set; }  
}

常用来作为Web接口的返回：

public Result SomeOperation()
{
    Result rsl = new Result();
    bool successful = doSomeThing();
    if (successful)
    {
        rsl.Code = 0;
        rsl.Message = "操作成功";
    }
    else
    {
        rsl.Code = -1;
        rsl.Message = "操作失败";
    }
    return rsl;
}

上述例子极具代表性。我们可能大部分时候只会返回固定的两种组合：返回Code为0，且Message为“操作成功”；返回Code为-1，且Message为“操作失败”。

因此，我们考虑给Result类增加如下的隐式类型转换

public static implicit operator Result(bool success)
{
    //此处使用了初始化器，用于在new出一个对象的同时，给对象的属性赋值。C#2.0引入，以后我们会讲到
    return success 
        ? new Result { Code = 0, Message = "操作成功" }
        : new Result { Code = -1, Message = "操作失败" };   
}

于是，Result类就实现了从bool类型到Result类型的隐式类型转换。对于原先的SomeOperation方法，便可以简化成这样：

public Result SomeOperation()
{
    bool successful = doSomeThing();
    return successful;  //会触发隐式类型转换
}

可以看到，我们可以通过类型转换，在适当场景下减少代码量。

Java不支持类型自定义转换。要达到类似效果，请实现一个专用处理方法，用于将传入的bool转换成Result。在每个需要做类型转换的地方调用该方法。

仅仅针对上述例子的话，Java可以直接使用枚举类型实现。但是，对于更普遍使用的 —— 包含数据返回的Result，则无法用枚举实现。因为要用到泛型，这里就不举例了。

语句（Statement）

lock

之所以提到lock语句块，一是因为它是语法级别的多线程互斥锁。二是几乎.Net的面试都会被问到。

lock块是一段语句块，它在同一时间仅允许一个线程进入该块。

lock (x)
{
    //做一些只能单线程进行的操作
}

lock为语法级别的，使用起来非常简单，所以深受欢迎。

在使用lock时，仍然有一些注意事项：

1. 用于lock的对象只能是引用类型
2. 用于lock的对象应当避免是public的，以免超出预期控制范围
3. 避免lock string类型的对象。这是.Net的机制所决定的。在.Net中，相同的字符串会指向同一块存储区域，即使是计算后得来的字串（因为string是不可变类型）。
4. 避免lock(this)。

Java的对照物为synchronized，而且它可以使用在更多的地方。

• synchronized可用作开启语句块，用法于lock相同，作用也一致。不同于lock一般要避免lock(this)，synchronized则一般直接synchronized(this)。
• synchronized还可以用于修饰方法，表明整个方法均满足线程互斥，相当于整个方法被synchronized(this)包裹。
• synchronized还可用于修饰静态的方法，同样表明整个方法均满足线程互斥。但此时不再限制在对象内，任何对该方法的调用都是互斥的。也就是说，如果你是使用对象调用的此静态方法，它表现为对所有对象都互斥。
• synchronized还可以使用synchronized(类名.class)，此时这个类的所有静态方法都会使用互斥锁。

说明注释（文档性注释，Documentation Comment）

C#的说明注释，格式为///开头的一段XML

• 说明注释的每一行都是以三个/开头（可以多，但不可以少）
• 说明注释的是XML格式的，需要符合XML定义。例如：标签需要有开和关。

使用了说明注释描述的类、方法、参数等，在被引用时，IDE会给出说明提示。

说明注释举例：

/// 

/// 随机选择一个元素样本
/// 
/// 元素类型
/// 待选择样本
/// 随机选择的样本
public static T SelectRandom(this IEnumerable source) { ... } //此处定义了扩展方法，扩展方法在C#3.0引入

说明注释可在编译设置中启用生成XML文档的情况下，自动生成XML描述文档。该文档有很多用途，例如：

• 打成Nuget包后，如果存在XML文档，引用者在使用类库时，IDE会给出说明提示。
• Swagger组件可以直接读取XML文档内容，自动生成Swagger文档。

To CShaper：做为对比，Java的说明注释为 /**开头， */结尾的一段。每一行都是*开头，具体section则以@开头的。

//==Java==
/**
* 计算平方
* @param num 要计算的数
* @return num的平方
*/
public double square(double num) { ... }

预处理指令（Preprocessor Directive）

与C++的宏指令一样，以#开头的指令为预处理指令，是工作在编译阶段的指令。该指令只会影响编译器工作，不会生成为IL代码。作用是告诉编译器应该怎么做。

这里只讲两组常用的指令：

#define和#if

#define指令用于定义标记（类似于C++的宏定义）

#if指令用于判断标记是否存在，对应的指令还有#else、#endif

典型的应用场景：Debug模式判断。

在Debug模式下，当前编译上下文会定义DEBUG标记。可以利用#if来插入仅Debug模式下可见的调试代码。

例如：

#if DEBUG
bool flag = true;
#else
bool flag = false;
#endif

则在Debug模式下，flag为true。

再次强调一下：#if的判断发生在编译阶段。因而，分支未命中的那部分代码，根本不会被编译进dll或exe。如上例中，IL中只会出现bool flag = true;编译后的代码。bool flag = false;则不会被编译。

#region

#region为区域折叠标记，对应的结束标记为#endregion。区域可以提供名称。

被区域折叠标记包裹的代码，在IDE中可以作为一个整体折叠起来。

这在拆分较大的类时非常好用。可以使代码看起来更整洁。

//在IDE中，下面的#region到#endregion之间的代码可以折叠为一行。折叠后的位置仅显示区域名称“私有方法”
#region 私有方法
//在这里定义一些私有方法
#endregion

特性（Attribute）

C#中的特性，与Java的注解（Annotation）是同义词。

特性是一类特殊的类。它标记在特定位置，用来给类、方法、参数、返回值等添加额外的声明、元数据信息。

定义特性：

• 声明一个类，继承自Attribute类，该类是一个抽象类，是所有特性的基类。
• 在该类上标注AttributeUsageAttribute特性，该特性用于指明所声明的特性类的作用目标、是否允许多重标注、是否允许派生类继承等信息。
  • AttributeUsageAttribute的构造器含一个参数，表示允许的作用目标。它是一个AttributeTargets类型的位枚举：
    • Assembly，值为0x1，作用于应用程序集
    • Module，值为0x2，作用于模块
    • Class，值为0x4，作用于类
    • Struct，值为0x8，作用于结构
    • Enum，值为0x10，作用于枚举
    • Constructor，值为0x20，作用于构造器
    • Method，值为0x40，作用于方法
    • Property，值为0x80，作用于属性
    • Field，值为0x100，作用于字段
    • Event，值为0x200，作用于事件
    • Interface，值为0x400，作用于接口
    • Parameter，值为0x800，作用于参数
    • Delegate，值为0x1000，作用于委托
    • ReturnValue，值为0x2000，作用于方法的返回值
    • GenericParameter，值为0x4000，作用于泛型类型参数（C#2.0）
    • All，值为0x7FFF，即等于上述所有位枚举的按位或，作用于上述任何目标
  • AttributeUsageAttribute包含bool类型属性AllowMultiple，表示是否允许在同个元素上标注多次
  • AttributeUsageAttribute包含bool类型属性Inherited，表示是否允许派生类或派生类对应元素继承此特性
• 规范而言，特性类的类名，一般以Attribute结尾

[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)] //指明AllowNullAttribute的作用对象为属性、字段或者方法的参数。并指定不允许派生类继承该特性
public sealed class AllowNullAttribute : Attribute
{
}

使用特性:

• 使用特性的语法为[特性]，标注在修饰目标之前。
• 如果要同时使用多个特性，既可以使用[特性1][特性2]的语法，也可以使用[特性1, 特性2]的语法
• 如果特性类有含参构造方法，则可以使用语法[特性(构造器参数列表)]调用。
• 如果特性类包含公开属性，可以在使用特性时指定属性值，语法为[特性(构造器参数列表, 属性1 = 值1, 属性2 = 值2, ...)]。但是需注意，能够用此语法指定的属性值，只能是编译时常量、或者数组的初始化表达式（C#2.0，初始化器。不知为何，对于数组，此处不支持直接使用{}这种最简形式）。如果属性的类型无法使用常量进行赋值，则无法通过上述方法在使用时指定属性值。
• 如果特性类以Attribute结尾，则使用特性时可以简写：省略Attribute后缀。

public class Test
{
    [AllowNull]  //省略了Attribute后缀
    private string name;

    [AllowNullAttribute, CheckPhone] //同时使用两个特性
    private string phone;

    [JsonProperty("no")] //使用具有含参构造器的特性
    private int number;

    [Document("obj的文档", Url = "http://doc.somedomain.com/obj")] //采用DocumentAttribute的一个string参数的构造器，同时指定其属性Url的值
    private object obj;
}

Java的注解，虽然与C#的特性同义，但是也有不少差异。
Java的自定义注解的声明和使用：

• 声明自定义注解：
  • 通过@interface关键词，因而注解是一个特殊类型，而非class。它默认继承Annotation接口，并且不能继承和实现其他类和接口。
  • 注解类只能是public或者friedly（即无修饰符）的，
  • 定义注解有者独特的语法。注解中的字段被称之为元素。定义时以()结尾，圆括号内不能有参数。并且可以在其后面紧跟default关键词提供默认值。元素的类型只能是简单数据类型、String、Class类（大体相当于C#的Type类）、枚举、注解和上述类型的数组。
  • 使用@Target标注注解的作用目标。它是个ElementType类型的枚举，可以取值的范围：
    • TYPE：作用于类
    • FIELD：作用于字段
    • METHOD：作用于方法
    • PARAMETER：作用于方法
    • CONSTRUCTOR：作用于构造器
    • LOCAL_VARIABLE：作用于局部变量
    • ANNOTATION_TYPE：作用于注解类
    • PACKAGE：作用于Package
    • TYPE_PARAMETER：作用于泛型的类型参数
    • TYPE_USE：作用于任何目标，即上述所有目标
  • 使用@Inherited标注注解是否允许派生类继承
  • 使用@Retention来标识注解的生存周期。它是个RetentionPolicy类型的枚举，支持：
    • SOURCE：仅在源码中有效，编译时被丢弃（请类比预处理指令）
    • CLASS：默认值。指编译后存在于.class的字节码文件中，可以用于某些工具对.class文件进行动态修改。但不会被加载到内存中，无法在运行时获取该注解。
    • RUNTIME：最常用的生存周期范围。编译后在.class字节码中，会被加载到JVM中，并且可以在运行时通过反射获取。

    对比之下，C#没有这样的机制。所有特性都是运行时可见的，相当于RUNTIME。

• 使用注解
  • 通过@注解名使用注解。
  • 未提供default值的元素，必须在使用时指定值。有default值的则可以省略。
  • 如需要指明元素值，单个元素时可以使用@注解名(值)，多个元素时可以使用@注解名(元素1名称 = 元素1值, 元素2名称 = 元素2值, ...)。
  • 对数组类型的元素指定值：若只有一个元素，可以直接指定单个元素的值；若有多个元素，可以通过{项1, 项2, ...}来指定值。
• 举例

  //==Java==
  @Target({ElementType.METHOD, ElementType.TYPE})  //该注解可作用于方法或类
  @Retention(RetentionPolicy.RUNTIME)  //该注解是运行时可见
  public @interface AutoLog {  //定义还有两个字段元素的注解@AutoLog
      String name();  //name没有默认值，使用时必须指定值
      int[] levels() default {0, 1}; //levels有默认值，使用时可以省略值
  }
  //使用注解，作用于类
  @AutoLog(name = "测试类", levels = 0) //指定元素的值，其中level是数组类型，因而既可以直接指定单个元素值，也可已用{}指定多个元素值
  public class Test {
  }
  

显式指定特性的目标

特性的作用目标，也可以显式的指定。语法是[作用目标:特性1,特性2...]。

可以指定的目标：

关键词	含义
assembly	整个程序集
module	当前程序集模块
field	字段
event	事件
method	方法， 或属性的访问器
param	方法参数，或setter的参数
property	属性
return	方法、索引器、getter返回值
type	结构、类、接口、枚举或委托

例如：

[method: Validated] //指定作用于方法
int Method1(){ return 0; } 
int ConvertInt([param:NotNull] string data) { return 0; } //指定作用于参数
[return : NotNull] //指明作用于返回值
public string CombineNames(string firstName, string lastName) { return string.Empty; }

assembly和module作用域比较特殊。绝大部分的特性作用于特定的语言元素，但是目标为assembly和module的特性作用于应用程序集和模块。例如：指定应用程序集的版本，可以这么指定

[assembly: AssemblyVersion("1.0.0.0")]

特性中的@符号

特性类的Attribute后缀不是强制要求，但是以Attribute作为后缀的特性在使用时可以省略后缀。因而，考虑一种特殊情况：

[AttributeUsage(AttributeTargets.Class)]
public class Info : Attribute
{
   private string information;

   public Info(string info)
   {
      information = info;
   }
}

[AttributeUsage(AttributeTargets.Method)]
public class InfoAttribute : Attribute
{
   private string information;

   public InfoAttribute(string info)
   {
      information = info;
   }
}

上例定义了两个特性。一个是Info，作用于类；另一个是InfoAttribute，作用于方法。

这两个特性，一个带后缀，一个不带。这样定义两个不同的Attribute是合法的（类名不同嘛）。但是要如何分别使用这两个特性呢？

如果仍然采用省略Attribute的后缀的语法，会出现二义性：

[Info("some string")] //会报错，编译器无法确定调用的是Info还是InfoAttribute

此时，调用Info时，在Info前加@符即可。而调用InfoAttribute，使用全名。

[@Info("This is a class.")] //使用@Info调用Info特性
public class Example
{
   [InfoAttribute("This is a method.")]//调用InfoAttribute时使用全名
   public static void SomeMethod()
   {
   }
}

反射（Reflection）

同Java和绝大多数的高级语言一样，C#也有反射机制。反射其实是个很大的话题，这里只做简要介绍。

Type类

C#的反射，核心是Type类。

C#中的任何类型，都可以描述为Type类的对象。

对于对象，可以通过GetType方法，获取用于描述其类型的Type对象。该方法定义于object上，任何类型都继承了该方法。这也包括值类型。

而如果不使用对象，想直接通过类型获取描述该类型的Type对象，则可以使用typeof运算符。

不同的是，GetType是运行时获取Type对象的，而typeof运算符是在编译阶段获取的。

Type typeInt = 1.GetType();   //通过对象的GetType方法，获取Type对象
Console.WriteLine(typeInt.Name);  //输出为Int32
Type typeInt2 = typeof(int);  //通过typeof运算符，作用于类型，获取Type对象
Console.WriteLine(typeInt2.Name);  //输出为Int32

获取Type对象后，可以通过该对象获取该类型的各种信息。如：字段、属性、方法、特性等等。

下面列出Type对象一些常用的方法：

• GetProperties：获取属性列表
• GetFields：获取字段列表
• GetMethods：获取方法列表
• GetCustomAttributes：获取自定义特性列表

与Type类对应的Java类是Class类。虽然Java也有Type，但是Java的Type是接口，而Class实现了该接口。通过对象来获取Class对象实例时，需要使用对象的getClass方法（类比GetType）；通过类名获取时，则使用类名.class（与typeof运算符作用相同，缺点是泛型类型不可以使用）。

关于为什么泛型类.class不可用，这就是Java的硬伤 —— 泛型类型擦除导致的了。我们会在C#2.0介绍泛型时，作为对比对Java的类型擦除做出介绍。

is运算符

可以通过is运算符，来判断某个对象是不是某个类型。

在如下情况下，is运算符返回true

• 对象的实际类型是精确的目标类型
• 对象的实际类型实现了目标接口
• 对象的实际类型是目标类型的派生类型
• 对象拆箱后类型为目标的值类型
• 对象的实际类型隐式继承目标类
• is的右侧是object

因为任何类型都被认为是object类型的，所以任何对象，无论它的类型是某个class、某个struct、某个enum还是某个delegate，判断其is object，返回都是true。

对于右侧类型是左侧对象的隐式继承类的情况，is运算符都会返回true。如任何enum对象，判断is Enum都是true。任何值类型对象，判断is ValueType都是true。

这里有个非常特殊的情况：Enum类本身是引用类型的，它继承自ValueType。但是一个Enum类型的对象（由enum类型装箱的来），判断is ValueType却是false。

int a = 1;
bool isInt = a is int; //true
bool isObject = a is object;  //true
bool isValueType = a is ValueType;  //true
bool isStruct = a is Enum;  //false
object obj = a; //装箱
bool isInt2 = obj is int; //true，拆箱后为int

NovelBook novelBook = new NovelBook();  //假设NovelBook类继承自Book类，且实现了IBook接口
bool isNovelBook =  novelBook is NovelBook; //true
bool isBook =  novelBook is Book; //true
bool isIBookImplement = novelBook is IBook; //true
Book book = novelBook;
bool isNovelBook2 = book is NovelBook; //true，判断实际类型

Java对应的运算符是instanceof。所不同的是：

• instanceof只能用于引用类型，无法用于基本类型。
• instanceof会进行编译器检查，明确无法进行类型转换的会报错，无法编译。C#虽然也会做编译器检查，但是仅仅是给出警告。

as运算符

as运算符类似类型转换，用于将对象转换成指定类型。

someObject as SomeClass等价于someObject is SomeClass ? (SomeClass)someObject : (SomeClass)null

因此，它跟强制类型转换有关，但又不同：

• as右侧的类型，只能适用于引用类型，不可适用于值类型
• as不会抛出异常，如果无法进行类型转换，会返回null

as不同于is，在编译器阶段验证时，如果确认对象无法进行到目标类型的类型转换，则会报错。

unsafe上下文

要使用unsafe上下文，必须在项目的编译设置中勾选允许不安全代码选项。它在实际项目中使用较少。

unsafe是一个关键词，用于描述一段不安全的代码。它可以修饰类，也可以修饰方法，还可以直接在语句中通过{}启用一段代码块。在unsafe上下文中，允许编写非托管的代码，这允许不安全的内存操作：直接使用指针。

public unsafe class Class1 //在该类内部所有方法内可以使用指针
{
}
public class Class2
{
    public unsafe void DoSomething() { ... }  //在该方法内可以使用指针
}
public class Class3
{
    public void DoSomething() 
    {
        unsafe   //在接下来的unsafe块内可以使用指针
        {
            ...
        }
    }
}

关于指针，用过C++的同学一定非常熟悉。

指针是一种指向内存区域的变量，它的变量本身存储的是所指向的内存区域的地址。指针指向的可以是单个数据，也可以是一串数据组成的数组的起始位置。

指针的语法同C++完全一致，声明指针使用*，取指针所指区域作为引用使用*运算符，取变量的地址使用&运算符，取指针所指的struct对象下的字段作为引用使用->运算符。

因为直接使用指针时，无法使用垃圾回收机制。因此C#规定unsafe块中的指针不能是引用类型的。换言之，必须是非托管类型的，而且是完全非托管的。具体来说，指针只能是以下类型之一：

• 非托管类型（Unmanaged Type），具体说来，可以是：
  • sbyte、byte、short、ushort、int、uint、long、ulong、char、float、double、decimal、bool
  • 枚举类型
  • struct
    • 需要注意，这要求struct内定义的所有字段均不含引用类型。如果有struct的嵌套，则每一层的struct也不能有引用类型
• 指针类型（即多重指针，如byte**）
• void类型（即void*），表示未知类型的指针

给指针赋值，有三种方式：

• 使用&运算符，但需要满足：
  • 运算符的操作数必须是左值类型，即变量
  • 操作数要么是满足上面要求的值类型，要么是值类型的数组元素。如果使用数组元素，则需要固定（fixed）
• 指向数组
  • 可以使用直接分配到栈空间上（使用stackalloc）的数组
  • 使用托管数组名赋值，也需要固定（使用fixed）。
• 指针赋值给指针

具体来说，如果要使用&给指针赋值为数组的某个元素地址，则会遇到问题：因为托管代码中引用类型的地址并非固定的，它可能被GC回收并重新分配。因此我们需要告诉编译器，将这个数组的位置固定在堆空间中，不再变化。这就要求将赋值语句限制在fixed块内。或者，如果你试图创建与C++相似的数组的话，可以直接将数组分配到栈空间内。

例1：

//下列代码在unsafe上下文中
int x = 1;
int* pX = &x;  //取x的地址
int[] y = new int[100];
fixed (int* pY = &y[0])  //此处必须使用fixed固定，否则编译器报错
{
}
fixed (int* pY2 = y)  //直接赋值为数组，这跟赋值为数组第一个元素的地址含义相同
{
}
int* pZ = stackalloc int[100]; //直接将内存分配在栈上（这样该数组便与C++的数组分配方式相同了）

例2：

//下列代码在unsafe上下文中
string str = "12345678";
fixed (char* pStr = str)  //string依然可以看作char数组
{
    char* current = pStr;
    *current++ = 'a';
    *current++ = 'b';
    *current++ = 'c';
    *current++ = 'd';
}
Console.WriteLine(str);  //输出为 abcd5678

fixed除了用作fixed块之外，还可以直接给unsafe的struct声明fixed的数组。这要求数组必须是sbyte、byte、short、ushort、int、uint、long、ulong、char、float、double、decimal、bool之一（注意，跟指针相比，fixed的数组类型不可以是decimal）。此时定义的语法退化为C++的语法：[]放在字段名后面，并且必须提供大小，且不能用new初始化。它将被分配在栈空间上，与stackalloc相同。

unsafe struct SomeStruct
{
    fixed int data[15];
    public void Test()
    {
        fixed (int* dataPtr = data)
        {
        }
    }
}

fixed和stackalloc也都只能在unsafe上下文中使用。(从C# 7.2开始，stackalloc可以分配给Span，因而可以用于非unsafe上下文了)

PS：事实上，我们会更多使用IntPtr和Marsha1来进行指针和非托管的内存操作。使用它们无需开启不安全上下文。

虽然不是语法级别的支持，但是Java仍可以参考Unsafe类，它也能实现内存的直接操作。同样的，它也很少被用到。

---

洋洋洒洒，啰啰嗦嗦，终于把1.0讲完了。接下来我们将进入到C#2.0。

C# 2.0 —— 追赶 + 创新

C# 2.0仍然走在追赶Java这位前辈的路上，不过仍然是追赶和创新并存。例如同为泛型，C#对泛型做了优化，使得C#的泛型为“真”泛型。

C# 2.0支持以下语法：

泛型（Generic）

C#2.0 正式引入了泛型。这是C#和Java都有的重要的机制。它的灵感明显来源于C++的模板（template），但是要进化得多。C#的泛型支持：

• 泛型类
• 泛型接口
• 泛型方法

public interface IGenericClass //定义泛型接口
{
}
public class GenericClass : IGenericClass  //定义泛型类，该类实现了泛型接口，此处接口的T是class的泛型参数T传入
{
    public void Add(T data) { } //使用泛型类的类型作为参数的方法
    public void Compare(T data1, TOther data2) { }  //定义泛型方法
}
public class MultipleGenericClass //多个泛型参数
{
}

语法上，Java与C#相差不大。仅在泛型方法的定义上有所区别：Java将泛型参数放在返回类型前面，而C#
放在方法名后面（跟泛型类定义一致）：

//==Java==
public <T> void add(T data){}

需要注意：

• 泛型与非泛型的同名类、同签名方法，是两个不同的类、方法。
• 泛型类型个数不一样的类、方法，也是不同的类和方法。

因此，SomeClass和SomeClass是两个不同的类。SomeClass和SomeClass`也是不同的类。这与Java不同。

这里要重点讲讲C#泛型与Java泛型的区别：

Java其实是“伪”泛型的，它的泛型类型只存在于编译器检查阶段，在进入JVM时会进行对泛型类型擦除：一直擦除到规定的类型上界（指定extends的情况下为extends的类型，否则为Object）。（指定extends的语法叫做泛型通配符，我们在C#的协变和逆变章节中，会作为比较进行介绍。）

例如下面的代码：

//==Java==
public class SomeClass<T>{
    T field;
}

在编译后，T会被擦除至Object类型。因而实际编译的后的类与下面的原始类型等价：

//==Java==
public class SomeClass{
    Object field;
}

不信？我们看下面的代码：

//==Java==
SomeClass<String> obj1 = new SomeClass<String>();
SomeClass<Integer> obj2 = new SomeClass<Integer>();
System.out.println(obj1.getClass() == obj2.getClass); 

上面的代码会输出true。SomeClass和SomeClass