<think>我们被要求提供C#所有关键字的列表及其用法示例。根据C#语言规范,关键字分为保留关键字(reserved keywords)和上下文关键字(contextual keywords)。保留关键字在任何地方都是关键字,而上下文关键字仅在特定的语言结构中才有特殊含义。
首先,列出所有保留关键字和上下文关键字,然后为每个关键字提供简要说明和一个简单的代码示例。
注意:由于关键字数量较多,我们将尽量简洁地展示每个关键字的用法。有些关键字(如`get`、`set`)通常作为属性的一部分,而有些(如`where`)用于泛型约束或LINQ查询。
我们将按照字母顺序排列关键字,并分为两部分:保留关键字和上下文关键字。
参考:C# 8.0规范中的关键字列表。
保留关键字(Reserved Keywords):
abstract, as, base, bool, break, byte, case, catch, char, checked, class, const, continue, decimal, default, delegate, do, double, else, enum, event, explicit, extern, false, finally, fixed, float, for, foreach, goto, if, implicit, in, int, interface, internal, is, lock, long, namespace, new, null, object, operator, out, override, params, private, protected, public, readonly, ref, return, sbyte, sealed, short, sizeof, stackalloc, static, string, struct, switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, ushort, using, virtual, void, volatile, while
上下文关键字(Contextual Keywords):
add, alias, ascending, async, await, by, descending, dynamic, equals, from, get, global, group, into, join, let, nameof, notnull, on, orderby, partial, remove, select, set, unmanaged, value, var, when, where, yield
注意:上下文关键字在特定上下文中才有特殊含义,在其他地方可以作为标识符使用。
由于关键字数量较多,我们将为每个关键字提供一个简短的描述和一个小示例。对于某些关键字,可能需要结合上下文来理解。
由于篇幅限制,我们不会为每个关键字都写一个完整的程序,而是提供简短的代码片段。
开始编写:</think>### C# 所有关键字列表及使用示例
以下是 C# 语言的所有关键字分类说明及实用代码示例(基于 C# 10 规范),分为**保留关键字**和**上下文关键字**两大类:
---
#### 一、保留关键字(77个)
在任何上下文中均不能用作标识符。
| 关键字 | 作用描述 | 示例代码 |
|--------------|-----------------------------|--------------------------------------------------------------------------|
| `abstract` | 定义抽象类或抽象方法 | `abstract class Shape { public abstract void Draw(); }` [^1] |
| `as` | 安全类型转换 | `object obj = "text"; string s = obj as string;` |
| `base` | 访问基类成员 | `class Derived : Base { public override void Print() => base.Print(); }` |
| `bool` | 布尔类型声明 | `bool isActive = true;` |
| `break` | 跳出循环或switch | `while(true) { if(condition) break; }` |
| `byte` | 8位无符号整数 | `byte pixel = 0xFF;` |
| `case` | switch分支 | `switch(value) { case 1: ... break; }` |
| `catch` | 异常捕获 | `try {...} catch(Exception ex) {...}` |
| `char` | 字符类型 | `char letter = 'A';` |
| `checked` | 启用算术溢出检查 | `checked { int max = int.MaxValue + 1; } // 抛出异常` |
| `class` | 定义类 | `class Person { public string Name {get; set;} }` |
| `const` | 定义常量 | `const double PI = 3.14;` |
| `continue` | 跳过当前循环迭代 | `for(int i=0; i<10; i++) { if(i==5) continue; ... }` |
| `decimal` | 高精度浮点数 | `decimal price = 19.99m;` |
| `default` | 默认值或switch默认分支 | `int num = default; // 0` |
| `delegate` | 定义委托类型 | `delegate void Log(string msg);` |
| `do` | do-while循环 | `do { ... } while(condition);` |
| `double` | 双精度浮点数 | `double distance = 123.456;` |
| `else` | if条件分支 | `if(x>0) {...} else {...}` |
| `enum` | 定义枚举 | `enum Color { Red, Green, Blue }` |
| `event` | 声明事件 | `event EventHandler Clicked;` |
| `explicit` | 显式类型转换运算符 | `public static explicit operator int(MyClass obj) {...}` |
| `extern` | 声明外部方法 | `[DllImport("user32.dll")] extern static void MessageBeep();` |
| `false` | 布尔假值 | `bool isValid = false;` |
| `finally` | 异常处理最终块 | `try {...} finally { Cleanup(); }` |
| `fixed` | 固定指针地址 | `fixed (int* p = arr) { ... }` |
| `float` | 单精度浮点数 | `float temperature = 36.5f;` |
| `for` | for循环 | `for(int i=0; i<10; i++) {...}` |
| `foreach` | 集合迭代 | `foreach(var item in list) {...}` |
| `goto` | 跳转到标签 | `goto exit; ... exit: return;` |
| `if` | 条件判断 | `if(score >= 60) Pass();` |
| `implicit` | 隐式类型转换运算符 | `public static implicit operator string(MyClass obj) {...}` |
| `in` | 泛型逆变/foreach迭代变量 | `foreach(var item in collection) {...}` |
| `int` | 32位整数 | `int count = 100;` |
| `interface` | 定义接口 | `interface IDrawable { void Draw(); }` |
| `internal` | 程序集内访问 | `internal class Helper { ... }` |
| `is` | 类型检查 | `if(obj is string) {...}` |
| `lock` | 线程同步 | `lock(_syncObj) { ... }` [^3] |
| `long` | 64位整数 | `long universeAge = 13_800_000_000;` |
| `namespace` | 定义命名空间 | `namespace MyApp.Data { ... }` |
| `new` | 创建实例/隐藏基类成员 | `var list = new List<string>();` |
| `null` | 空引用 | `string name = null;` |
| `object` | 所有类型基类 | `object obj = "Hello";` |
| `operator` | 重载运算符 | `public static Vector operator +(Vector a, Vector b) {...}` |
| `out` | 输出参数 | `bool TryParse(string s, out int result) {...}` |
| `override` | 重写虚方法 | `public override string ToString() {...}` |
| `params` | 可变参数 | `void Print(params object[] values) {...}` |
| `private` | 私有访问 | `private int _id;` |
| `protected` | 保护访问 | `protected virtual void OnEvent() {...}` |
| `public` | 公共访问 | `public string Name { get; }` |
| `readonly` | 只读字段 | `public readonly DateTime Created = DateTime.Now;` |
| `ref` | 引用传递参数 | `void Swap(ref int a, ref int b) { (a,b) = (b,a); }` |
| `return` | 方法返回值 | `int Add(int a, int b) { return a + b; }` |
| `sbyte` | 8位有符号整数 | `sbyte offset = -128;` |
| `sealed` | 禁止继承/重写 | `sealed class FinalClass {...}` |
| `short` | 16位整数 | `short port = 8080;` |
| `sizeof` | 获取类型字节大小 | `int size = sizeof(int); // 4` |
| `stackalloc` | 栈上分配数组 | `int* buffer = stackalloc int[64];` |
| `static` | 静态成员 | `public static int Counter {get; set;}` |
| `string` | 字符串类型 | `string greeting = "Hello World";` |
| `struct` | 定义结构体 | `struct Point { public int X,Y; }` |
| `switch` | 多分支选择 | `switch(day) { case Day.Monday: ... break; }` |
| `this` | 当前实例引用 | `public void SetName(string name) { this.name = name; }` |
| `throw` | 抛出异常 | `throw new ArgumentNullException();` |
| `true` | 布尔真值 | `bool isReady = true;` |
| `try` | 异常处理 | `try { RiskyOperation(); } catch {...}` |
| `typeof` | 获取类型元数据 | `Type t = typeof(string);` |
| `uint` | 32位无符号整数 | `uint pixels = 0xFFFFFFFF;` |
| `ulong` | 64位无符号整数 | `ulong bigNumber = 18_446_744_073_709_551_615;` |
| `unchecked` | 禁用算术溢出检查 | `unchecked { int max = int.MaxValue + 1; // 不抛异常 }` |
| `unsafe` | 启用不安全代码 | `unsafe { byte* ptr = ...; }` |
| `ushort` | 16位无符号整数 | `ushort port = 80;` |
| `using` | 资源管理/命名空间导入 | `using var file = new StreamReader(...);` |
| `virtual` | 声明虚方法 | `public virtual void Render() {...}` |
| `void` | 无返回值 | `public void Log(string message) {...}` |
| `volatile` | 多线程可见性保证 | `volatile bool _isRunning;` [^2] |
| `while` | while循环 | `while(!queue.IsEmpty) {...}` |
---
#### 二、上下文关键字(24个)
仅在特定上下文中有特殊含义,可作标识符使用。
| 关键字 | 作用场景 | 示例代码 |
|--------------|-----------------------------|--------------------------------------------------------------------------|
| `add` | 事件访问器 | `event EventHandler Clicked { add {...} remove {...} }` |
| `alias` | 命名空间别名 | `using WinForms = System.Windows.Forms;` |
| `ascending` | LINQ排序 | `from p in products orderby p.Price ascending select p` |
| `async` | 异步方法声明 | `async Task DownloadAsync() { ... }` |
| `await` | 等待异步操作 | `var data = await httpClient.GetStringAsync(url);` |
| `by` | LINQ分组 | `from s in students group s by s.Class into g` |
| `descending` | LINQ倒序排序 | `from p in products orderby p.Price descending select p` |
| `dynamic` | 动态类型 | `dynamic obj = GetExternalData(); obj.CallMethod();` |
| `equals` | LINQ连接条件 | `from a in listA join b in listB on a.ID equals b.ID` |
| `from` | LINQ查询起始 | `from item in collection where item.Active select item` |
| `get` | 属性访问器 | `public string Name { get => _name; }` |
| `global` | 全局命名空间 | `global::System.Console.WriteLine();` |
| `group` | LINQ分组 | `from s in students group s by s.Age` |
| `into` | LINQ中间结果 | `from s in students group s by s.Class into classGroup` |
| `join` | LINQ连接 | `from p in products join c in categories on p.CategoryId equals c.Id` |
| `let` | LINQ中间变量 | `from s in students let fullName = s.First + " " + s.Last select fullName` |
| `nameof` | 获取标识符名称 | `if(value == null) throw new ArgumentNullException(nameof(value));` |
| `notnull` | 泛型非空约束 | `void Print<T>(T obj) where T : notnull {...}` |
| `on` | LINQ连接条件 | `join c in customers on o.CustomerId equals c.Id` |
| `orderby` | LINQ排序 | `from p in products orderby p.Price, p.Name select p` |
| `partial` | 分部类/方法 | `partial class MyClass { ... }` |
| `remove` | 事件访问器 | `event EventHandler Clicked { add {...} remove {...} }` |
| `select` | LINQ投影 | `select new { p.Name, p.Price }` |
| `set` | 属性访问器 | `public string Name { set => _name = value; }` |
| `unmanaged` | 泛型非托管类型约束 | `void Process<T>(T data) where T : unmanaged {...}` |
| `value` | 属性set访问器参数 | `public string Name { set => _name = value; }` |
| `var` | 隐式类型变量 | `var list = new List<string>();` |
| `when` | 异常过滤/模式匹配 | `catch(Exception ex) when (ex is TimeoutException) {...}` |
| `where` | LINQ过滤/泛型约束 | `from n in numbers where n > 10 select n` |
| `yield` | 迭代器返回值 | `IEnumerable<int> GetNumbers() { yield return 1; yield return 2; }` [^1] |
---
### 关键特性说明
1. **类型系统**:
- 值类型:`struct`, `enum`, 数值类型(`int`, `float`等)
- 引用类型:`class`, `interface`, `delegate`, `object`, `string`
- 特殊类型:`dynamic`, `var`
2. **并发控制**:
- `lock` 确保线程同步[^3]
- `volatile` 保证多线程可见性[^2]
- `async`/`await` 简化异步编程
3. **内存管理**:
- `stackalloc` 栈内存分配
- `fixed` 固定托管对象地址
- `using` 自动释放资源(实现`IDisposable`)
4. **泛型约束**:
```csharp
void Process<T>(T item)
where T : notnull, IComparable // 多重约束
{ ... }
```
---
### 完整示例:迭代器与异步方法
```csharp
using System.Collections.Generic;
using System.Threading.Tasks;
public class Demo
{
// yield迭代器 [^1]
public static IEnumerable<int> Fibonacci(int count)
{
int a = 0, b = 1;
for (int i = 0; i < count; i++)
{
yield return a;
(a, b) = (b, a + b);
}
}
// async/await异步方法
public async Task<string> FetchDataAsync()
{
using var client = new HttpClient();
return await client.GetStringAsync("https://api.example.com/data");
}
}
```