C# 所有关键字语法详解

C# 所有关键字语法详解

C# 是一种面向对象的编程语言，由微软公司开发，是.NET 平台的核心语言之一。C# 包含了一系列关键字，这些关键字在语言中具有特殊的含义，不能用作标识符。本文将详细介绍 C# 中的所有关键字及其语法和使用场景。

一、C# 关键字分类

C# 关键字可以分为以下几大类：

1. ​​访问修饰符关键字​​
2. ​​类型关键字​​
3. ​​语句关键字​​
4. ​​运算符关键字​​
5. ​​上下文关键字​​
6. ​​其他关键字​​

二、访问修饰符关键字

访问修饰符用于控制类、方法、属性等的访问级别。

关键字	描述
public	不限制访问，任何代码都可以访问。
private	仅限于包含它的类或结构体内部访问。
protected	仅限于包含它的类或派生类内部访问。
internal	仅限于当前程序集内部访问。
protected internal	结合 protected 和 internal，即当前程序集或派生类可以访问。
private protected	仅限于当前程序集中的派生类可以访问（C# 7.2 引入）。

示例

public class MyClass
{
    private int privateField;
    protected int protectedField;
    internal int internalField;
    protected internal int protectedInternalField;
    private protected int privateProtectedField; // C# 7.2+
    public int PublicField;
}

三、类型关键字

类型关键字用于定义或声明数据类型。

关键字	描述
bool	布尔类型，值为 true 或 false。
byte	8 位无符号整数。
char	16 位 Unicode 字符。
decimal	128 位高精度十进制数。
double	64 位双精度浮点数。
float	32 位单精度浮点数。
int	32 位有符号整数。
long	64 位有符号整数。
sbyte	8 位有符号整数。
short	16 位有符号整数。
uint	32 位无符号整数。
ulong	64 位无符号整数。
ushort	16 位无符号整数。
object	所有类型的基类。
string	Unicode 字符串。
dynamic	动态类型，运行时确定类型。
void	表示方法不返回值。

示例

bool isActive = true;
byte age = 25;
char grade = 'A';
decimal price = 19.99m;
double temperature = 36.6;
float pi = 3.14f;
int count = 100;
long bigNumber = 10000000000L;
sbyte smallNumber = -128;
short shortNumber = 32767;
uint unsignedInt = 4294967295u;
ulong hugeNumber = 18446744073709551615ul;
ushort ushortNumber = 65535;
object obj = new object();
string name = "Alice";
dynamic dynamicVar = 10;
void DoSomething() { }

四、语句关键字

语句关键字用于控制程序的执行流程。

1. 控制流关键字

关键字	描述
if	条件语句。
else	与 if 配合使用，表示条件不成立时的执行路径。
elif (C# 9.0+)	否则如果，简化多层嵌套的 if-else 结构。
switch	多分支选择语句。
case	switch 语句中的分支标签。
default	switch 语句中的默认分支。
while	循环语句，条件为真时重复执行。
do	循环语句，至少执行一次，然后检查条件。
for	循环语句，通常用于已知循环次数的情况。
foreach	遍历集合或数组中的每个元素。
break	终止最近的封闭循环或 switch 语句。
continue	跳过当前循环的剩余部分，继续下一次迭代。
goto	无条件跳转到指定的标签。
return	从方法中返回值（如果有返回值）或简单地退出方法。
throw	抛出异常。
try	尝试执行代码块，可能抛出异常。
catch	捕获并处理异常。
finally	无论是否发生异常都会执行的代码块。
checked	在检查的上下文中执行算术运算，防止溢出。
unchecked	在未检查的上下文中执行算术运算，允许溢出。

示例

int number = 10;

if (number > 5)
{
    Console.WriteLine("Number is greater than 5.");
}
else if (number == 5) // C# 9.0+ 可以使用 elif
{
    Console.WriteLine("Number is equal to 5.");
}
else
{
    Console.WriteLine("Number is less than 5.");
}

switch (number)
{
    case 10:
        Console.WriteLine("Number is 10.");
        break;
    default:
        Console.WriteLine("Number is not 10.");
        break;
}

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

foreach (var item in new int[] { 1, 2, 3 })
{
    Console.WriteLine(item);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine(ex.Message);
}
finally
{
    Console.WriteLine("This will always execute.");
}

2. 流程控制关键字（C# 9.0+）

关键字	描述
=>	Lambda 表达式操作符。
??	空合并运算符，提供默认值。
?.	空条件运算符，安全访问成员。
??=	空合并赋值运算符（C# 8.0+）。
switch 表达式	返回值的 switch 表达式（C# 8.0+）。

示例

int? nullableInt = null;
int value = nullableInt ?? 10; // 如果 nullableInt 为 null，则 value 为 10

string name = null;
Console.WriteLine(name?.ToUpper()); // 不会抛出异常

nullableInt ??= 20; // 如果 nullableInt 为 null，则赋值为 20

int result = number switch
{
    10 => 100,
    _ => 0
};

五、运算符关键字

运算符关键字用于执行特定的操作。

关键字	描述
new	创建对象实例或隐藏继承的成员。
typeof	获取类型的 Type 对象。
sizeof	获取值类型占用的字节数（仅在 unsafe 上下文中使用）。
checked	检查算术运算是否溢出（与语句关键字相同，但也可作为运算符）。
unchecked	不检查算术运算是否溢出（与语句关键字相同，但也可作为运算符）。
default	获取类型的默认值。
delegate	定义委托类型（C# 1.0+）。
is	检查对象是否为指定类型或满足条件（C# 7.0+ 增强）。
as	尝试将对象转换为指定类型，失败返回 null（C# 1.0+）。
await	异步等待任务完成（C# 5.0+）。
async	标记方法、lambda 表达式或匿名方法为异步（C# 5.0+）。
nameof	获取变量、类型或成员的名称（C# 6.0+）。
stackalloc	在堆栈上分配内存（仅在 unsafe 上下文中使用）。

示例

// 使用 new 创建对象
var person = new Person();

// 获取类型信息
Type type = typeof(Person);

// 获取默认值
int defaultValue = default(int);

// 类型检查
if (obj is string str)
{
    Console.WriteLine(str.Length);
}

// 类型转换
string strObj = obj as string;
if (strObj != null)
{
    Console.WriteLine(strObj);
}

// 异步方法
public async Task DoSomethingAsync()
{
    await Task.Delay(1000);
}

// nameof 运算符
string propertyName = nameof(Person.Name);

// stackalloc (unsafe context)
unsafe
{
    int* numbers = stackalloc int[10];
}

六、上下文关键字

上下文关键字在特定上下文中具有特殊含义，但也可以用作标识符。

关键字	描述
add	用于事件声明，定义添加事件处理程序的方法。
alias	用于 extern alias 指令，为程序集创建别名。
ascending	用于 orderby 子句，表示升序排序。
by	用于查询表达式中的分组操作。
descending	用于 orderby 子句，表示降序排序。
from	用于查询表达式，指定数据源。
group	用于查询表达式，对数据进行分组。
join	用于查询表达式，连接两个数据源。
let	用于查询表达式，引入范围变量。
on	用于 join 子句，指定连接条件。
orderby	用于查询表达式，对结果进行排序。
select	用于查询表达式，选择要返回的数据。
set	用于属性声明，定义设置属性值的方法。
value	用于属性和事件的访问器中，表示赋值的值。
where	用于查询表达式，筛选数据。
partial	用于定义分部类、结构体或方法。
params	用于方法参数，允许传递可变数量的参数。
ref	用于按引用传递参数。
out	用于方法返回多个值，通过参数输出。
in	用于按引用传递参数，但保证不被修改（C# 7.2+）。
var	隐式类型，编译器推断变量类型（C# 3.0+）。
when	用于 catch 块中的条件过滤（C# 6.0+）或 switch 表达式中的条件（C# 8.0+）。
global	用于全局命名空间别名（C# 10.0+）。

示例

// 事件声明
public event EventHandler MyEvent
{
    add { /* 添加处理程序 */ }
    remove { /* 移除处理程序 */ }
}

// 查询表达式
var query = from p in people
            where p.Age > 18
            orderby p.Name ascending
            select p;

// 分部类
public partial class MyClass { }

// 隐式类型
var number = 10; // 编译器推断为 int

// ref 和 out
void ModifyValue(ref int x)
{
    x = 20;
}

void GetValue(out int x)
{
    x = 30;
}

// params
void PrintNumbers(params int[] numbers)
{
    foreach (var num in numbers)
    {
        Console.WriteLine(num);
    }
}

七、其他关键字

关键字	描述
abstract	用于类或成员，表示抽象的，不能实例化或必须被重写。
base	用于访问基类的成员。
bool	布尔类型（已包含在类型关键字中）。
break	终止循环或 switch 语句（已包含在语句关键字中）。
case	switch 语句中的分支标签（已包含在语句关键字中）。
catch	捕获异常（已包含在语句关键字中）。
checked	检查算术运算是否溢出（已包含在语句关键字中）。
class	定义类。
const	定义常量。
continue	跳过当前循环的剩余部分（已包含在语句关键字中）。
decimal	十进制类型（已包含在类型关键字中）。
default	默认值或 switch 语句中的默认分支（已包含在语句关键字中）。
delegate	定义委托类型（已包含在运算符关键字中）。
do	循环语句（已包含在语句关键字中）。
double	双精度浮点类型（已包含在类型关键字中）。
else	条件语句的分支（已包含在语句关键字中）。
enum	定义枚举类型。
event	定义事件。
explicit	定义显式转换运算符。
extern	表示方法在外部实现（通常与 DllImport 一起使用）。
false	布尔值（已包含在类型关键字中）。
finally	异常处理中的最终代码块（已包含在语句关键字中）。
fixed	固定缓冲区或变量地址（仅在 unsafe 上下文中使用）。
float	单精度浮点类型（已包含在类型关键字中）。
for	循环语句（已包含在语句关键字中）。
foreach	遍历集合（已包含在语句关键字中）。
goto	无条件跳转（已包含在语句关键字中）。
if	条件语句（已包含在语句关键字中）。
implicit	定义隐式转换运算符。
in	按引用传递参数并保证不被修改（C# 7.2+，也用于查询表达式）
int	整数类型（已包含在类型关键字中）。
interface	定义接口。
internal	访问修饰符（已包含在访问修饰符关键字中）。
is	类型检查（已包含在运算符关键字中）。
lock	用于线程同步，锁定对象。
namespace	定义命名空间。
new	创建对象或隐藏成员（已包含在运算符关键字中）。
null	表示空引用。
object	所有类型的基类（已包含在类型关键字中）。
operator	定义运算符重载。
out	方法返回多个值（已包含在运算符关键字中）。
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	表示字段可能被多个线程同时访问，不应被编译器优化。
where	泛型约束（C# 2.0+）。
while	循环语句（已包含在语句关键字中）。

示例

// 抽象类
public abstract class Animal
{
    public abstract void MakeSound();
}

// 接口
public interface IFlyable
{
    void Fly();
}

// 实现接口和抽象类
public class Bird : Animal, IFlyable
{
    public override void MakeSound()
    {
        Console.WriteLine("Chirp");
    }

    public void Fly()
    {
        Console.WriteLine("Flying");
    }
}

// 枚举
public enum DaysOfWeek
{
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}

// 结构体
public struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

// 使用 using 语句管理资源
using (var stream = new FileStream("file.txt", FileMode.Open))
{
    // 使用 stream
}

// 泛型约束
public class GenericClass<T> where T : IComparable
{
    public T Max(T a, T b)
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

八、关键字总结表

为了便于查阅，以下是 C# 关键字的分类总结表：

分类	关键字
​​访问修饰符​​	public, private, protected, internal, protected internal, private protected (C# 7.2+)
​​类型​​	bool, byte, char, decimal, double, float, int, long, sbyte, short, uint, ulong, ushort, object, string, dynamic, void, var (C# 3.0+), dynamic (C# 4.0+)
​​语句​​	if, else, elif (C# 9.0+), switch, case, default, while, do, for, foreach, break, continue, goto, return, throw, try, catch, finally, checked, unchecked, lock
​​运算符​​	new, typeof, sizeof (unsafe), checked (operator), unchecked (operator), default, delegate, is, as, await, async, nameof, stackalloc (unsafe), => (lambda), ??, ?., ??=
​​上下文​​	add, alias, ascending, by, descending, from, group, join, let, on, orderby, select, set, value, where, partial, params, ref, out, in (C# 7.2+), global (C# 10.0+)
​​其他​​	abstract, base, class, const, continue, decimal, default, delegate, do, double, else, enum, event, explicit, extern, false, finally, fixed, float, for, foreach, goto, if, implicit, in (C# 7.2+), int, interface, internal, is, lock, namespace, new, null, object, operator, out, params, private, protected, public, readonly, ref, return, sbyte, sealed, short, sizeof (unsafe), stackalloc (unsafe), static, string, struct, switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, ushort, using, virtual, void, volatile, where, while

通过本文的详细介绍，相信您已经对 C# 中的关键字有了全面的了解。掌握这些关键字的使用是编写高效、可维护 C# 代码的基础。建议在实际开发中结合具体场景深入学习和实践这些关键字的应用。