c#关键字大全

C# 关键字
请参见 发送反馈意见


关键字是对编译器具有特殊意义的预定义保留标识符。它们不能在程序中用作标识符，除非它们有一个 @ 前缀。例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。

本主题中的第一个表列出的关键字在 C# 程序的任何部分都是保留标识符。本主题中的第二个表列出了 C# 中的上下文关键字。上下文关键字仅在受限制的程序上下文中具有特殊含义，并且可在该上下文外部用作标识符。通常，在将新关键字添加到 C# 语言的同时，也会将它们添加为上下文关键字，以便避免破坏用该语言的早期版本编写的程序。

( 摘自MSDN 共92个关键字 )



abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。在类声明中使用 abstract 修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

抽象类具有以下特性：

抽象类不能实例化。

抽象类可以包含抽象方法和抽象访问器。

不能用 sealed（C# 参考）修饰符修改抽象类，这意味着抽象类不能被继承。

从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。

在方法或属性声明中使用 abstract 修饰符以指示方法或属性不包含实现。

抽象方法具有以下特性：

抽象方法是隐式的虚方法。

只允许在抽象类中使用抽象方法声明。

因为抽象方法声明不提供实际的实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号 ({ })。例如：

复制代码
public abstract void MyMethod();


实现由一个重写方法override（C# 参考）提供，此重写方法是非抽象类的一个成员。

在抽象方法声明中使用 static 或 virtual 修饰符是错误的。

除了在声明和调用语法上不同外，抽象属性的行为与抽象方法一样。

在静态属性上使用 abstract 修饰符是错误的。

在派生类中，通过包括使用 override 修饰符的属性声明，可以重写抽象的继承属性。

抽象类必须为所有接口成员提供实现。

实现接口的抽象类可以将接口方法映射到抽象方法上。例如：

复制代码
interface I
{
void M();
}
abstract class C: I
{
public abstract void M();
}


示例
在本例中，DerivedClass 类是从抽象类 BaseClass 派生的。抽象类包含一个抽象方法 AbstractMethod 和两个抽象属性 X 和 Y。

复制代码
// abstract_keyword.cs
// Abstract Classes
using System;
abstract class BaseClass // Abstract class
{
protected int _x = 100;
protected int _y = 150;
public abstract void AbstractMethod(); // Abstract method
public abstract int X

{ get; }
public abstract int Y { get; }
}

class DerivedClass : BaseClass
{
public override void AbstractMethod()
{
_x++;
_y++;
}

public override int X // overriding property
{
get
{
return _x + 10;
}
}

public override int Y // overriding property
{
get
{
return _y + 10;
}
}

static void Main()
{
DerivedClass o = new DerivedClass();
o.AbstractMethod();
Console.WriteLine("x = {0}, y = {1}", o.X, o.Y);
}
}

复制代码
x = 111, y = 161


注释
在上面的示例中，如果试图通过使用下面的语句将抽象类实例化：

复制代码
BaseClass bc = new BaseClass(); // Error


将出现错误，指出编译器无法创建抽象类“BaseClass”
event 关键字用于在发行者类中声明事件。

备注
下面的示例演示如何声明和引发将 EventHandler 用作基础委托类型的事件。有关演示如何使用泛型 EventHandler<(Of <(TEventArgs>)>) 委托类型、如何订阅事件以及如何创建事件处理程序方法的完整代码示例，请参见如何：发布符合 .NET Framework 准则的事件（C# 编程指南）。

复制代码
public class Publisher
{
// Declare the delegate (if using non-generic pattern).
public delegate void SampleEventHandler(object sender, SampleEventArgs e);

// Declare the event.
public event SampleEventHandler SampleEvent;

// Wrap the event in a protected virtual method
// to enable derived classes to raise the event.
protected virtual void RaiseSampleEvent()
{
// Raise the event by using the () operator.
SampleEvent(this, new SampleEventArgs("Hello"));
}
}


事件是特殊类型的多路广播委托，仅可从声明它们的类或结构（发行者类）中调用。如果其他类或结构订阅了该事件，则当发行者类引发该事件时，会调用其事件处理程序方法。有关更多信息和代码示例，请参见事件（C# 编程指南） 和委托（C# 编程指南）。

事件可标记为 public、private、protected、internal 或 protected internal。这些访问修饰符定义类的用户访问事件的方式。有关更多信息，请参见访问修饰符（C# 编程指南）。

关键字和事件
下面的关键字可应用于事件。

关键字
说明
更多信息

static
即使类没有实例，调用方也能在任何时候使用该事件。
静态类和静态类成员（C# 编程指南）

virtual
允许派生类通过使用 override 关键字来重写事件行为。
继承（C# 编程指南）

sealed
指定对于派生类它不再属虚拟性质。


abstract
编译器不会生成 add 和 remove 事件访问器块，因此派生类必须

提供自己的实现。



通过使用 static 关键字，可以将事件声明为静态事件。即使类没有任何实例，调用方也能在任何时候使用静态事件。有关更多信息，请参见静态类和静态类成员（C# 编程指南）。

通过使用 virtual 关键字，可以将事件标记为虚拟事件。这样，派生类就可以通过使用 override 关键字来重写事件行为。有关更多信息，请参见继承（C# 编程指南）。重写虚事件的事件也可以为 sealed，以表示其对于派生类不再是虚事件。最后，可以将事件声明为 abstract，这意味着编译器不会生成 add 和 remove 事件访问器块。因此派生类必须提供其自己的实现。
在 C# 中，new 关键字可用作运算符、修饰符或约束。

new 运算符
用于创建对象和调用构造函数。

new 修饰符
用于向基类成员隐藏继承成员。

new 约束
用于在泛型声明中约束可能用作类型参数的参数的类型。

struct 类型是一种值类型，通常用来封装小型相关变量组，例如，矩形的坐标或库存商品的特征。下面的示例显示了一个简单的结构声明。

复制代码
public struct Book
{
public decimal price;
public string title;
public string author;
}


备注
结构还可以包含构造函数、常量、字段、方法、属性、索引器、运算符、事件和嵌套类型，但如果同时需要上述几种成员，则应当考虑改为使用类作为类型。

结构可以实现接口，但它们无法继承另一个结构。因此，结构成员无法声明为 protected。
as 运算符用于在兼容的引用类型之间执行转换。例如：

复制代码
string s = someObject as string;
if (s != null)
{
// someObject is a string.
}


备注
as 运算符类似于强制转换操作。但是，如果无法进行转换，则 as 返回 null 而非引发异常。请看下面的表达式：

复制代码
expression as type


它等效于以下表达式，但只计算一次 expression。

复制代码
expression is type ? (type)expression : (type)null


注意，as 运算符只执行引用转换和装箱转换。as 运算符无法执行其他转换，如用户定义的转换，这类转换应使用强制转换表达式来执行。

示例
复制代码
// cs_keyword_as.cs
// The as operator.
using System;
class Class1
{
}

class Class2
{
}

class MainClass
{
static void Main()
{
object[] objArray = new object[6];
objArray[0] = new Class1();
objArray[1] = new Class2();
objArray[2] = "hello";
objArray[3] = 123;
objArray[4] = 123.4;
objArray[5] = null;

for (int i = 0; i < objArray.Length; ++i)
{
string s = objArray[i] as string;
Console.Write("{0}:", i);
if (s != null)
{

Console.WriteLine("'" + s + "'");
}
else
{
Console.WriteLine("not a string");
}
}
}
}

复制代码
0:not a string
1:not a string
2:'hello'
3:not a string
4:not a string
5:not a string

explicit 关键字用于声明必须使用强制转换来调用的用户定义的类型转换运算符。例如，在下面的示例中，此运算符将名为 Fahrenheit 的类转换为名为 Celsius 的类：

复制代码
// Must be defined inside a class called Farenheit:
public static explicit operator Celsius(Farenheit f)
{
return new Celsius((5.0f/9.0f)*(f.degrees-32));
}


可以如下所示调用此转换运算符：

复制代码
Farenheit f = new Farenheit(100.0f);
Celsius c = (Celsius)f;


备注
转换运算符将源类型转换为目标类型。源类型提供转换运算符。与隐式转换不同，必须通过强制转换的方式来调用显式转换运算符。如果转换操作可能导致异常或丢失信息，则应将其标记为 explicit。这可以防止编译器无提示地调用可能产生无法预见后果的转换操作。

省略此强制转换将导致编译时错误 编译器错误 CS0266
null 关键字是表示不引用任何对象的 null 引用的文字值。null 是引用类型变量的默认值。

C# 2.0 引入了可为 null 的类型，这是可以设置成未定义值的数据类型。请参见 可以为 null 的类型（C# 编程指南）。
switch 语句是一个控制语句，它通过将控制传递给其体内的一个 case 语句来处理多个选择和枚举。例如：

复制代码
int caseSwitch = 1;
switch (caseSwitch)
{
case 1:
Console.WriteLine("Case 1");
break;
case 2:
Console.WriteLine("Case 2");
break;
default:
Console.WriteLine("Default case");
break;
}


备注
控制传递给与开关的值匹配的 case 语句。switch 语句可以包括任意数目的 case 实例，但是任何两个 case 语句都不能具有相同的值。语句体从选定的语句开始执行，直到 break 将控制传递到 case 体以外。在每一个 case 块（包括上一个块，不论它是 case 语句还是 default 语句）的后面，都必须有一个跳转语句（如 break）。但有一个例外，（与 C++ switch 语句不同）C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。这个例外是当 case 语句中没有代码时。

如果没有任何 case 表达式与开关值匹配，则控制传递给跟在可选 default 标签后的语句。如果没有 default 标签，则控制传递到 switch 以外。

示例
复制代码
// statements_switch.cs
using System;
class SwitchTest
{
static void Main()
{
Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");
Console.Write("Please enter your selection: ");
str

ing s = Console.ReadLine();
int n = int.Parse(s);
int cost = 0;
switch(n)
{
case 1:
cost += 25;
break;
case 2:
cost += 25;
goto case 1;
case 3:
cost += 50;
goto case 1;
default:
Console.WriteLine("Invalid selection. Please select 1, 2, or 3.");
break;
}
if (cost != 0)
{
Console.WriteLine("Please insert {0} cents.", cost);
}
Console.WriteLine("Thank you for your business.");
}
}

复制代码
2

复制代码
Coffee sizes: 1=Small 2=Medium 3=Large
Please enter your selection: 2
Please insert 50 cents.
Thank you for your business.


下面的示例显示了空 case 标签可以从一个 case 标签贯穿到另一个。

复制代码
// statements_switch2.cs
using System;
class SwitchTest
{
static void Main()
{
int n = 2;
switch(n)
{
case 1:
case 2:
case 3:
Console.WriteLine("It's 1, 2, or 3.");
break;
default:
Console.WriteLine("Not sure what it is.");
break;
}
}
}

复制代码
It's 1, 2, or 3.


代码讨论
在前面的示例中，整型变量 n 用于 switch case。注意还可以直接使用字符串变量 s。在这种情况下，可以以下列方式使用 switch case：

复制代码
switch(s)
{
case "1":
// ...
case "2":
// ...
}
base 关键字用于从派生类中访问基类的成员：

调用基类上已被其他方法重写的方法。

指定创建派生类实例时应调用的基类构造函数。

基类访问只能在构造函数、实例方法或实例属性访问器中进行。

从静态方法中使用 base 关键字是错误的。

示例
在本例中，基类 Person 和派生类 Employee 都有一个名为 Getinfo 的方法。通过使用 base 关键字，可以从派生类中调用基类的 Getinfo 方法。

复制代码
// keywords_base.cs
// Accessing base class members
using System;
public class Person
{
protected string ssn = "444-55-6666";
protected string name = "John L. Malgraine";

public virtual void GetInfo()
{
Console.WriteLine("Name: {0}", name);
Console.WriteLine("SSN: {0}", ssn);
}
}
class Employee : Person
{
public string id = "ABC567EFG";
public override void GetInfo()
{
// Calling the base class GetInfo method:
base.GetInfo();
Console.WriteLine("Employee ID: {0}", id);
}
}

class TestClass
{
static void Main()
{
Employee E = new Employee();
E.GetInfo();
}
}


本示例显示如何指定在创建派生类实例时调用的基类构造函数。

复制代码
// ke

ywords_base2.cs
using System;
public class BaseClass
{
int num;

public BaseClass()
{
Console.WriteLine("in BaseClass()");
}

public BaseClass(int i)
{
num = i;
Console.WriteLine("in BaseClass(int i)");
}

public int GetNum()
{
return num;
}
}

public class DerivedClass : BaseClass
{
// This constructor will call BaseClass.BaseClass()
public DerivedClass() : base()
{
}

// This constructor will call BaseClass.BaseClass(int i)
public DerivedClass(int i) : base(i)
{
}

static void Main()
{
DerivedClass md = new DerivedClass();
DerivedClass md1 = new DerivedClass(1);
}
}



输出
复制代码
Name: John L. Malgraine
SSN: 444-55-6666
Employee ID: ABC567EFG


有关其他示例，请参见 new、virtual 和 override。

输出
复制代码
in BaseClass()
in BaseClass(int i)

extern 修饰符用于声明在外部实现的方法。extern 修饰符的常见用法是在使用 Interop 服务调入非托管代码时与 DllImport 属性一起使用。在这种情况下，还必须将方法声明为 static，如下示例所示：

复制代码
[DllImport("avifil32.dll")]
private static extern void AVIFileInit();

注意：
extern 关键字还可以定义外部程序集别名，使得可以从单个程序集中引用同一组件的不同版本。有关更多信息，请参见外部别名（C# 参考）。


将 abstract（C# 参考）和 extern 修饰符一起使用来修改同一成员是错误的。使用 extern 修饰符意味着方法在 C# 代码的外部实现，而使用 abstract 修饰符意味着在类中未提供方法实现。

注意：
extern 关键字在使用上比在 C++ 中有更多限制。若要与 C++ 关键字进行比较，请参见 C++ Language Reference 中的 Using extern to Specify Linkage。


示例
在该示例中，程序接收来自用户的字符串并将该字符串显示在消息框中。程序使用从 User32.dll 库导入的 MessageBox 方法。

复制代码
using System;
using System.Runtime.InteropServices;
class MainClass
{
[DllImport("User32.dll")]
public static extern int MessageBox(int h, string m, string c, int type);

static int Main()
{
string myString;
Console.Write("Enter your message: ");
myString = Console.ReadLine();
return MessageBox(0, myString, "My Message Box", 0);
}
}


此示例使用 C 程序创建一个 DLL，在下一示例中将从 C# 程序调用该 DLL。

复制代码
// cmdll.c
// Compile with: /LD
int __declspec(dllexport) SampleMethod(int i)
{
return i*10;
}


该示例使用两个文件 CM.cs 和 Cmdll.c 来说明 extern。C 文件是示例 2 中创建的外部 DLL，它从 C# 程序内调用。

复制代码
// cm.cs
using System;
using System.Runtime.InteropServices;
public class

MainClass
{
[DllImport("Cmdll.dll")]
public static extern int SampleMethod(int x);

static void Main()
{
Console.WriteLine("SampleMethod() returns {0}.", SampleMethod(5));
}
}

复制代码
SampleMethod() returns 50.


备注
生成项目：

使用 Visual C++ 命令行将 Cmdll.c 编译为 DLL：

cl /LD Cmdll.c

使用命令行编译 CM.cs：

csc CM.cs

这将创建可执行文件 CM.exe。运行此程序时，SampleMethod 将值 5 传递到 DLL 文件，该文件将此值乘以 10 返回。
object 类型在 .NET Framework 中是 Object 的别名。在 C# 的统一类型系统中，所有类型（预定义类型、用户定义类型、引用类型和值类型）都是直接或间接从 Object 继承的。可以将任何类型的值赋给 object 类型的变量。将值类型的变量转换为对象的过程称为“装箱”。将对象类型的变量转换为值类型的过程称为“取消装箱”。有关更多信息，请参见装箱和取消装箱。

示例
下面的示例演示了 object 类型的变量如何接受任何数据类型的值，以及 object 类型的变量如何在 .NET Framework 中使用 Object 的方法。

复制代码
// keyword_object.cs
using System;
class SampleClass
{
public int i = 10;
}

class MainClass
{
static void Main()
{
object a;
a = 1; // an example of boxing
Console.WriteLine(a);
Console.WriteLine(a.GetType());
Console.WriteLine(a.ToString());

a = new SampleClass();
SampleClass classRef;
classRef = (SampleClass)a;
Console.WriteLine(classRef.i);
}
}

复制代码
1
System.Int32
1
10

this 关键字引用类的当前实例，还可用作扩展方法的第一个参数的修饰符。

注意：
本文讨论对类实例使用 this。有关其在扩展方法中使用的更多信息，请参见扩展方法（C# 编程指南）。


以下是 this 的常用用途：

限定被相似的名称隐藏的成员，例如：

复制代码
public Employee(string name, string alias)
{
https://www.360docs.net/doc/fd7029957.html, = name;
this.alias = alias;
}


将对象作为参数传递到其他方法，例如：

复制代码
CalcTax(this);


声明索引器，例如：

复制代码
public int this [int param]
{
get { return array[param]; }
set { array[param] = value; }
}


由于静态成员函数存在于类一级，并且不是对象的一部分，因此没有 this 指针。在静态方法中引用 this 是错误的。

示例
在本例中，this 用于限定 Employee 类成员 name 和 alias，它们都被相似的名称隐藏。this 还用于将对象传递到属于其他类的方法 CalcTax。

复制代码
// keywords_this.cs
// this example
using System;
class Employee
{
private string name;
private string alias;
private decimal salary = 3000.00m;

// Constructor:
pub

lic Employee(string name, string alias)
{
// Use this to qualify the fields, name and alias:
https://www.360docs.net/doc/fd7029957.html, = name;
this.alias = alias;
}

// Printing method:
public void printEmployee()
{
Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);
// Passing the object to the CalcTax method by using this:
Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));
}

public decimal Salary
{
get { return salary; }
}
}
class Tax
{
public static decimal CalcTax(Employee E)
{
return 0.08m * E.Salary;
}
}

class MainClass
{
static void Main()
{
// Create objects:
Employee E1 = new Employee("Mingda Pan", "mpan");

// Display results:
E1.printEmployee();
}
}


输出
复制代码
Name: Mingda Pan
Alias: mpan
Taxes: $240.00


有关其他示例，请参见 class 和 struct。
bool 关键字是 System..::.Boolean 的别名。它用于声明变量来存储布尔值 true 和 false。

注意：
如果需要一个也可以有 null 值的布尔型变量，请使用 bool。有关更多信息，请参见可以为 null 的类型（C# 编程指南）。


文本
可将布尔值赋给 bool 变量。也可以将计算为 bool 类型的表达式赋给 bool 变量。

复制代码
// keyword_bool.cs
using System;
public class MyClass
{
static void Main()
{
bool i = true;
char c = '0';
Console.WriteLine(i);
i = false;
Console.WriteLine(i);

bool Alphabetic = (c > 64 && c < 123);
Console.WriteLine(Alphabetic);
}
}


输出
复制代码
True
False
False


转换
在 C++ 中，bool 类型的值可转换为 int 类型的值；也就是说，false 等效于零值，而 true 等效于非零值。在 C# 中，不存在 bool 类型与其他类型之间的相互转换。例如，下列 if 语句尽管在 C++ 中有效，但在 C# 中无效：

复制代码
int x = 123;
if (x) // Invalid in C#
{
printf_s("The value of x is nonzero.");
}


若要测试 int 类型的变量，必须将该变量与一个值（例如零）进行显式比较，如下所示：

复制代码
int x = 123;
if (x != 0) // The C# way
{
Console.Write("The value of x is nonzero.");
}


示例
在此例中，您从键盘输入一个字符，然后程序检查输入的字符是否是一个字母。如果字符是一个字母，则程序检查它是大写还是小写。这些检查是使用 IsLetter 和 IsLower（两者均返回 bool 类型）来执行的：

复制代码
// keyword_bool_2.cs
using System;
public class BoolTest
{
static void Main()
{
Console.Write("Enter a character: ");
char c = (char)Console.Read();
if (Char.IsLetter(c))
{
if (Char.IsLower(c))
{
C

onsole.WriteLine("The character is lowercase.");
}
else
{
Console.WriteLine("The character is uppercase.");
}
}
else
{
Console.WriteLine("Not an alphabetic character.");
}
}
}

复制代码
Enter a character: X
The character is uppercase.
Additional sample runs might look as follow:
Enter a character: x
The character is lowercase.

Enter a character: 2
The character is not an alphabetic character.


C# 语言规范
false（C# 参考）
请参见 发送反馈意见


用作重载运算符或文本：

false 运算符

false 标识符
false 运算符（C# 参考）
请参见 发送反馈意见


返回布尔值 true 以指示假，否则返回 false。这对于数据库中使用的表示 true、false 和 null（既非 true 也非 false）的类型很有用。

这些类型可用于控制 if、do、while 和 for 语句中以及条件表达式中的表达式。

如果类型定义了 false 运算符，则它还必须定义 true 运算符。

类型不能直接重载条件逻辑运算符 && 和 ||，但通过重载正则逻辑运算符以及运算符 true 与 false 可以达到同样的效果。
false 字面常数（C# 参考）
示例 请参见 发送反馈意见


表示布尔值 false。

示例
复制代码
// cs_keyword_false.cs
using System;
class TestClass
{
static void Main()
{
bool a = false;
Console.WriteLine( a ? "yes" : "no" );
}
}

复制代码
no

使用 operator 关键字来重载内置运算符，或提供类或结构声明中的用户定义转换。

示例
下面是一个非常简化的表示分数的类。该类重载了 + 和 * 运算符，以执行分数加法和乘法；同时提供了将 Fraction 类型转换为 double 类型的转换运算符。

复制代码
// cs_keyword_operator.cs
using System;
class Fraction
{
int num, den;
public Fraction(int num, int den)
{
this.num = num;
this.den = den;
}

// overload operator +
public static Fraction operator +(Fraction a, Fraction b)
{
return new Fraction(a.num * b.den + b.num * a.den,
a.den * b.den);
}

// overload operator *
public static Fraction operator *(Fraction a, Fraction b)
{
return new Fraction(a.num * b.num, a.den * b.den);
}

// user-defined conversion from Fraction to double
public static implicit operator double(Fraction f)
{
return (double)f.num / f.den;
}
}

class Test
{
static void Main()
{
Fraction a = new Fraction(1, 2);
Fraction b = new Fraction(3, 7);
Fraction c = new Fraction(2, 3);
Console.WriteLine((double)(a * b + c));
}
}

复制代码
0.880952380952381

throw 语句用于发出在程序执行期间出现反常

情况（异常）的信号。

备注
引发的异常是一个对象，该对象的类是从 System..::.Exception 派生的，例如：

复制代码
class MyException : System.Exception {}
// ...
throw new MyException();


通常 throw 语句与 try-catch 或 try-finally 语句一起使用。当引发异常时，程序查找处理此异常的 catch 语句。

也可以用 throw 语句重新引发已捕获的异常。有关更多信息和示例，请参见 try-catch 和 引发异常。

示例
此例演示如何使用 throw 语句引发异常。

复制代码
// throw example
using System;
public class ThrowTest
{
static void Main()
{
string s = null;

if (s == null)
{
throw new ArgumentNullException();
}

Console.Write("The string s is null"); // not executed
}
}


输出
发生 ArgumentNullException 异常。
break 语句用于终止最近的封闭循环或它所在的 switch 语句。控制传递给终止语句后面的语句（如果有的话）。

示例
在此例中，条件语句包含一个应该从 1 计数到 100 的计数器；但 break 语句在计数达到 4 后终止循环。

复制代码
// statements_break.cs
using System;
class BreakTest
{
static void Main()
{
for (int i = 1; i <= 100; i++)
{
if (i == 5)
{
break;
}
Console.WriteLine(i);
}
}
}

复制代码
1
2
3
4


下面的示例演示 break 在 switch 语句中的用法。

复制代码
// statements_break2.cs
// break and switch
using System;
class Switch
{
static void Main()
{
Console.Write("Enter your selection (1, 2, or 3): ");
string s = Console.ReadLine();
int n = Int32.Parse(s);

switch (n)
{
case 1:
Console.WriteLine("Current value is {0}", 1);
break;
case 2:
Console.WriteLine("Current value is {0}", 2);
break;
case 3:
Console.WriteLine("Current value is {0}", 3);
break;
default:
Console.WriteLine("Sorry, invalid selection.");
break;
}
}
}

复制代码
1

复制代码
Enter your selection (1, 2, or 3): 1
Current value is 1


注释
如果输入了 4，则输出为：

复制代码
Enter your selection (1, 2, or 3): 4
Sorry, invalid selection.

finally 块用于清除 try 块中分配的任何资源，以及运行任何即使在发生异常时也必须执行的代码。控制总是传递给 finally 块，与 try 块的退出方式无关。

备注
catch 用于处理语句块中出现的异常，而 finally 用于保证代码语句块的执行，与前面的 try 块的退出方式无关。

示例
在此例中，有一

个导致异常的无效转换语句。当运行程序时，您收到一条运行时错误信息，但 finally 子句仍继续执行并显示输出。

复制代码
// try-finally
using System;
public class MainClass
{
static void Main()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int)o;
}
finally
{
Console.Write("i = {0}", i);
}
}
}


注释
上面的示例将导致引发 System.InvalidCastException。

尽管捕捉了异常，但仍会执行 finally 块中包含的输出语句，即：

i = 123

有关 finally 的更多信息，请参见 try-catch-finally。
finally 块用于清除 try 块中分配的任何资源，以及运行任何即使在发生异常时也必须执行的代码。控制总是传递给 finally 块，与 try 块的退出方式无关。

备注
catch 用于处理语句块中出现的异常，而 finally 用于保证代码语句块的执行，与前面的 try 块的退出方式无关。

示例
在此例中，有一个导致异常的无效转换语句。当运行程序时，您收到一条运行时错误信息，但 finally 子句仍继续执行并显示输出。

复制代码
// try-finally
using System;
public class MainClass
{
static void Main()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int)o;
}
finally
{
Console.Write("i = {0}", i);
}
}
}


注释
上面的示例将导致引发 System.InvalidCastException。

尽管捕捉了异常，但仍会执行 finally 块中包含的输出语句，即：

i = 123

有关 finally 的更多信息，请参见 try-catch-finally。
out 关键字会导致参数通过引用来传递。这与 ref 关键字类似，不同之处在于 ref 要求变量必须在传递之前进行初始化。若要使用 out 参数，方法定义和调用方法都必须显式使用 out 关键字。例如：

复制代码
class OutExample
{
static void Method(out int i)
{
i = 44;
}
static void Main()
{
int value;
Method(out value);
// value is now 44
}
}


尽管作为 out 参数传递的变量不必在传递之前进行初始化，但需要调用方法以便在方法返回之前赋值。

ref 和 out 关键字在运行时的处理方式不同，但在编译时的处理方式相同。因此，如果一个方法采用 ref 参数，而另一个方法采用 out 参数，则无法重载这两个方法。例如，从编译的角度来看，以下代码中的两个方法是完全相同的，因此将不会编译以下代码：

复制代码
class CS0663_Example
{

// Compiler error CS0663: "Cannot define overloaded
// methods that differ only on ref and out".
public void SampleMethod(out int i) { }
public void SampleMethod(ref int i) { }
}


但是，如果一个方法采用 ref 或 out 参数，而另一个方法不采用这两类参数，则可以进行重载，如下所示：

复制代码
class RefOutOverloadExample
{
public void SampleMethod(int i) { }
public void SampleMethod(out int i) { }
}


备注
属性不是变量，因此不能作为 out 参数传递。

有关传递数组的信息，请参见使用 ref 和 out 传递数组（C# 编程指南）。

示例
当希望方法返回多个值时，声明 out 方法很有用。使用 out 参数的方法仍然可以将变量作为返回类型来访问（请参见 return），但它还可以将一个或多个对象作为 out 参数返回给调用方法。此示例使用 out 在一个方法调用中返回三个变量。请注意，第三个参数所赋的值为 Null。这样使方法可以有选择地返回值。

复制代码
class OutReturnExample
{
static void Method(out int i, out string s1, out string s2)
{
i = 44;
s1 = "I've been returned";
s2 = null;
}
static void Main()
{
int value;
string str1, str2;
Method(out value, out str1, out str2);
// value is now 44
// str1 is now "I've been returned"
// str2 is (still) null;
}
}


true（C# 参考）
请参见 发送反馈意见


用作重载运算符或文本：

true 运算符

true 标识符

true 运算符（C# 参考）
请参见 发送反馈意见


当由用户定义的类型定义时，返回 bool 值 true 以表示真，否则返回 false。这对于表示 true、false 和 null（既非 true 也非 false）的类型很有用，在数据库中使用了该运算符。

这些类型可用于控制 if、do、while 和 for 语句中以及条件表达式中的表达式。

如果类型定义了 true 运算符，它还必须定义 false 运算符。

类型不能直接重载条件逻辑运算符（&& 和 ||），但通过重载规则逻辑运算符和 true 与 false 运算符可以达到同样的效果。
true 字面常数（C# 参考）
示例 请参见 发送反馈意见


表示布尔值 true。

示例
复制代码
// cs_keyword_true.cs
using System;
class TestClass
{
static void Main()
{
bool a = true;
Console.WriteLine( a ? "yes" : "no" );
}
}

复制代码
yes

byte 关键字代表一种整型，该类型按下表所示存储值：

类型
范围
大小
.NET Framework 类型

byte
0 到 255
无符号 8 位整数
System..::.Byte


标识符
可如下例所示声明并初始化 byte 类型的变量：

复制代码
byte myByte = 255;


在以上声明中，整数 255 从 int 隐式转换为 byt

e。如果整数超出了 byte 的范围，将产生编译错误。

转换
存在从 byte 到 short、ushort、int、uint、long、ulong、float、double 或 decimal 的预定义隐式转换。

不能将更大存储大小的非文本数值类型隐式转换为 byte。有关整型的存储大小的更多信息，请参见 整型表（C# 参考）。例如，请看以下两个 byte 变量 x 和 y：

复制代码
byte x = 10, y = 20;


以下赋值语句将产生一个编译错误，原因是赋值运算符右侧的算术表达式在默认情况下的计算结果为 int 类型。

复制代码
// Error: conversion from int to byte:
byte z = x + y;


若要解决此问题，请使用强制转换：

复制代码
// OK: explicit conversion:
byte z = (byte)(x + y);


但是，在目标变量具有相同或更大的存储大小时，使用下列语句是可能的：

复制代码
int x = 10, y = 20;
int m = x + y;
long n = x + y;


同样，不存在从浮点型到 byte 类型的隐式转换。例如，除非使用显式强制转换，否则以下语句将生成一个编译器错误：

复制代码
// Error: no implicit conversion from double:
byte x = 3.0;
// OK: explicit conversion:
byte y = (byte)3.0;


调用重载方法时，必须使用显式转换。以下面使用 byte 和 int 参数的重载方法为例：

复制代码
public static void SampleMethod(int i) {}
public static void SampleMethod(byte b) {}


使用 byte 强制转换可保证调用正确的类型，例如：

复制代码
// Calling the method with the int parameter:
SampleMethod(5);
// Calling the method with the byte parameter:
SampleMethod((byte)5);


有关兼用浮点型和整型的算术表达式的信息，请参见 float 和 double。

有关隐式数值转换规则的更多信息，请参见 隐式数值转换表（C# 参考）。
fixed 语句（C# 参考）
示例 请参见 发送反馈意见


fixed 语句禁止垃圾回收器重定位可移动的变量。fixed 语句只能出现在不安全的上下文中。Fixed 还可用于创建固定大小的缓冲区。

备注
fixed 语句设置指向托管变量的指针并在 statement 执行期间“钉住”该变量。如果没有 fixed 语句，则指向可移动托管变量的指针的作用很小，因为垃圾回收可能不可预知地重定位变量。C# 编译器只允许在 fixed 语句中分配指向托管变量的指针。

复制代码
// assume class Point { public int x, y; }
// pt is a managed variable, subject to garbage collection.
Point pt = new Point();
// Using fixed allows the address of pt members to be
// taken, and "pins" pt so it isn't relocated.
fixed ( int* p = &pt.x )
{
*p = 1;
}


可以用数组或字符串的地址初始化指针：

复制代码
fixed (int* p = arr) ... // equivalent to p = &arr[0]
fixed (char* p = str) ... // equivalent to p =

&str[0]


只要指针的类型相同，就可以初始化多个指针：

复制代码
fixed (byte* ps = srcarray, pd = dstarray) {...}


要初始化不同类型的指针，只需嵌套 fixed 语句：

复制代码
fixed (int* p1 = &p.x)
{
fixed (double* p2 = &array[5])
{
// Do something with p1 and p2.
}
}


执行完语句中的代码后，任何固定变量都被解除固定并受垃圾回收的制约。因此，不要指向 fixed 语句之外的那些变量。

注意：
无法修改在 fixed 语句中初始化的指针。


在不安全模式中，可以在堆栈上分配内存。堆栈不受垃圾回收的制约，因此不需要被锁定。有关更多信息，请参见 stackalloc。

示例
复制代码
// statements_fixed.cs
// compile with: /unsafe
using System;

class Point
{
public int x, y;
}

class FixedTest
{
// Unsafe method: takes a pointer to an int.
unsafe static void SquarePtrParam (int* p)
{
*p *= *p;
}

unsafe static void Main()
{
Point pt = new Point();
pt.x = 5;
pt.y = 6;
// Pin pt in place:
fixed (int* p = &pt.x)
{
SquarePtrParam (p);
}
// pt now unpinned
Console.WriteLine ("{0} {1}", pt.x, pt.y);
}
}

复制代码
25 6

override（C# 参考）
示例 请参见 发送反馈意见


要扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现，必须使用 override 修饰符。

在此示例中，Square 类必须提供 Area 的重写实现，因为 Area 继承自抽象的 ShapesClass：

复制代码
abstract class ShapesClass
{
abstract public int Area();
}

class Square : ShapesClass
{
int x, y;
// Because ShapesClass.Area is abstract, failing to override
// the Area method would result in a compilation error.
public override int Area()
{
return x * y;
}
}


有关如何使用 override 关键字的更多信息，请参见使用 Override 和 New 关键字进行版本控制（C# 编程指南）和了解何时使用 Override 和 New 关键字。

备注
override 方法提供从基类继承的成员的新实现。由 override 声明重写的方法称为重写基方法。重写的基方法必须与 override 方法具有相同的签名。有关继承的信息，请参见继承（C# 编程指南）。

不能重写非虚方法或静态方法。重写的基方法必须是 virtual、abstract 或 override 的。

override 声明不能更改 virtual 方法的可访问性。override 方法和 virtual 方法必须具有相同的访问级别修饰符。

不能使用 new、static、virtual 或 abstract 修饰符来修改 override 方法。

重写属性声明必须指定与继承属性完全相同的访问修饰符、类型和名称，并且被重写的属性必须是 virtual、abst

ract 或 override 的。

示例
此示例定义了一个名为 Employee 的基类和一个名为 SalesEmployee 的派生类。SalesEmployee 类包括一个额外的属性 salesbonus，并重写方法 CalculatePay 以便将该属性考虑在内。

复制代码
using System;
class TestOverride
{
public class Employee
{
public string name;

// Basepay is defined as protected, so that it may be
// accessed only by this class and derrived classes.
protected decimal basepay;

// Constructor to set the name and basepay values.
public Employee(string name, decimal basepay)
{
https://www.360docs.net/doc/fd7029957.html, = name;
this.basepay = basepay;
}

// Declared virtual so it can be overridden.
public virtual decimal CalculatePay()
{
return basepay;
}
}

// Derive a new class from Employee.
public class SalesEmployee : Employee
{
// New field that will affect the base pay.
private decimal salesbonus;

// The constructor calls the base-class version, and
// initializes the salesbonus field.
public SalesEmployee(string name, decimal basepay,
decimal salesbonus) : base(name, basepay)
{
this.salesbonus = salesbonus;
}

// Override the CalculatePay method
// to take bonus into account.
public override decimal CalculatePay()
{
return basepay + salesbonus;
}
}

static void Main()
{
// Create some new employees.
SalesEmployee employee1 = new SalesEmployee("Alice",
1000, 500);
Employee employee2 = new Employee("Bob", 1200);

Console.WriteLine("Employee " + https://www.360docs.net/doc/fd7029957.html, +
" earned: " + employee1.CalculatePay());
Console.WriteLine("Employee " + https://www.360docs.net/doc/fd7029957.html, +
" earned: " + employee2.CalculatePay());
}
}

复制代码
Employee Alice earned: 1500
Employee Bob earned: 1200

try-catch 语句由一个 try 块后跟一个或多个 catch 子句构成，这些子句指定不同的异常处理程序。

备注
try 块包含可能导致异常的保护代码。该块一直执行到引发异常或成功完成为止。例如，下列强制转换 null 对象的尝试引发 NullReferenceException 异常：

复制代码
object o2 = null;
try
{
int i2 = (int)o2; // Error
}


catch 子句使用时可以不带任何参数，这种情况下它捕获任何类型的异常，并被称为一般 catch 子句。它还可以接受从 System..::.Exception 派生的对象参数，这种情况下它处理特定的异常。例如：

复制代码
catch (InvalidCastException e)
{
}


在同一个 try-catch 语句中可以使用一个以上的特定 catch 子句。这种情况下 catch 子句的顺序

很重要，因为会按顺序检查 catch 子句。将先捕获特定程度较高的异常，而不是特定程度较小的异常。

在 catch 块中可以使用 throw 语句再次引发已由 catch 语句捕获的异常。例如：

复制代码
catch (InvalidCastException e)
{
throw (e); // Rethrowing exception e
}


如果要再次引发当前由无参数的 catch 子句处理的异常，则使用不带参数的 throw 语句。例如：

复制代码
catch
{
throw;
}


在 try 块内部时应该只初始化其中声明的变量；否则，完成该块的执行前可能发生异常。例如，在下面的代码示例中，变量 x 在 try 块内初始化。试图在 Write(x) 语句中的 try 块外部使用此变量时将产生编译器错误：使用了未赋值的局部变量。

复制代码
static void Main()
{
int x;
try
{
// Don't initialize this variable here.
x = 123;
}
catch
{
}
// Error: Use of unassigned local variable 'x'.
Console.Write(x);
}


有关 catch 的更多信息，请参见 try-catch-finally。

示例
在此例中，try 块包含对可能导致异常的 ProcessString 方法的调用。catch 子句包含仅在屏幕上显示消息的异常处理程序。当从 MyMethod 内部调用 throw 语句时，系统查找 catch 语句并显示 Exception caught 消息。

复制代码
// try_catch_example.cs
using System;
class MainClass
{
static void ProcessString(string s)
{
if (s == null)
{
throw new ArgumentNullException();
}
}

static void Main()
{
try
{
string s = null;
ProcessString(s);
}
catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
}
}
}

复制代码
System.ArgumentNullException: Value cannot be null.
at MainClass.Main() Exception caught.


此例使用了两个 catch 语句。最先出现的最特定的异常被捕获。

复制代码
// try_catch_ordering_catch_clauses.cs
using System;
class MainClass
{
static void ProcessString(string s)
{
if (s == null)
{
throw new ArgumentNullException();
}
}

static void Main()
{
try
{
string s = null;
ProcessString(s);
}
// Most specific:
catch (ArgumentNullException e)
{
Console.WriteLine("{0} First exception caught.", e);
}
// Least specific:
catch (Exception e)
{
Console.WriteLine("{0} Second exception caught.", e);
}
}
}

复制代码
System.ArgumentNullException: Value cannot be null.
at MainClass.Main() First exception caught.


注释
在前面的示例中，如果从具体程度最低的 catch 子句

开始，您将收到以下错误信息：

A previous catch clause already catches all exceptions of this or a super type ('System.Exception')

但是，若要捕获特定程度最小的异常，请使用下面的语句替换 throw 语句：

throw new Exception();
switch（C# 参考）
示例 请参见 发送反馈意见


switch 语句是一个控制语句，它通过将控制传递给其体内的一个 case 语句来处理多个选择和枚举。例如：

复制代码
int caseSwitch = 1;
switch (caseSwitch)
{
case 1:
Console.WriteLine("Case 1");
break;
case 2:
Console.WriteLine("Case 2");
break;
default:
Console.WriteLine("Default case");
break;
}


备注
控制传递给与开关的值匹配的 case 语句。switch 语句可以包括任意数目的 case 实例，但是任何两个 case 语句都不能具有相同的值。语句体从选定的语句开始执行，直到 break 将控制传递到 case 体以外。在每一个 case 块（包括上一个块，不论它是 case 语句还是 default 语句）的后面，都必须有一个跳转语句（如 break）。但有一个例外，（与 C++ switch 语句不同）C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。这个例外是当 case 语句中没有代码时。

如果没有任何 case 表达式与开关值匹配，则控制传递给跟在可选 default 标签后的语句。如果没有 default 标签，则控制传递到 switch 以外。

示例
复制代码
// statements_switch.cs
using System;
class SwitchTest
{
static void Main()
{
Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");
Console.Write("Please enter your selection: ");
string s = Console.ReadLine();
int n = int.Parse(s);
int cost = 0;
switch(n)
{
case 1:
cost += 25;
break;
case 2:
cost += 25;
goto case 1;
case 3:
cost += 50;
goto case 1;
default:
Console.WriteLine("Invalid selection. Please select 1, 2, or 3.");
break;
}
if (cost != 0)
{
Console.WriteLine("Please insert {0} cents.", cost);
}
Console.WriteLine("Thank you for your business.");
}
}

复制代码
2

复制代码
Coffee sizes: 1=Small 2=Medium 3=Large
Please enter your selection: 2
Please insert 50 cents.
Thank you for your business.


下面的示例显示了空 case 标签可以从一个 case 标签贯穿到另一个。

复制代码
// statements_switch2.cs
using System;
class SwitchTest
{
static void Main()
{
int n = 2;
switch(n)
{
case 1:
case 2:
case 3:
Console.WriteLine("It's 1, 2, or 3.");
break;

default:
Console.WriteLine("Not sure what it is.");
break;
}
}
}

复制代码
It's 1, 2, or 3.


代码讨论
在前面的示例中，整型变量 n 用于 switch case。注意还可以直接使用字符串变量 s。在这种情况下，可以以下列方式使用 switch case：

复制代码
switch(s)
{
case "1":
// ...
case "2":
// ...
}

float（C# 参考）
示例 请参见 发送反馈意见


float 关键字表示存储 32 位浮点值的简单类型。下表显示了 float 类型的精度和大致范围。

类型
大致范围
精度
.NET Framework 类型

float
±1.5 × 10-45 到 ±3.4 × 1038
7 位
System..::.Single


标识符
默认情况下，赋值运算符右侧的实数被视为 double。因此，应使用后缀 f 或 F 初始化浮点型变量，如以下示例中所示：

复制代码
float x = 3.5F;


如果在以上声明中不使用后缀，则会因为您试图将一个 double 值存储到 float 变量中而发生编译错误。

转换
可在一个表达式中兼用数值整型和浮点型。在此情况下，整型将转换为浮点型。根据以下规则计算表达式：

如果其中一个浮点型为 double，则表达式的计算结果为 double 或 bool（在关系表达式或布尔表达式中）。

如果表达式中不存在 double 类型，则表达式的计算结果为 float 或 bool（在关系表达式或布尔表达式中）。

浮点表达式可以包含下列值集：

正零和负零

正无穷和负无穷

非数字值 (NaN)

有限的非零值集

有关这些值的更多信息，请参见 IEEE 网站上的“IEEE Standard for Binary Floating-Point Arithmetic”（二进制浮点算法的 IEEE 标准）。

示例
在下面的示例中，包含 int、short 和 float 类型的数学表达式得到一个 float 结果。请注意，表达式中没有 double。

复制代码
// keyword_float.cs
// Mixing types in expressions
using System;
class MixedTypes
{
static void Main()
{
int x = 3;
float y = 4.5f;
short z = 5;
Console.WriteLine("The result is {0}", x * y / z);
}
}


输出
复制代码
The result is 2.7

params 关键字可以指定在参数数目可变处采用参数的方法参数。

在方法声明中的 params 关键字之后不允许任何其他参数，并且在方法声明中只允许一个 params 关键字。

示例
复制代码
// cs_params.cs
using System;
public class MyClass
{

public static void UseParams(params int[] list)
{
for (int i = 0 ; i < list.Length; i++)
{
Console.WriteLine(list[i]);
}
Console.WriteLine();
}

public static void UseParams2(params object[] list)
{
for (int i = 0 ; i < list.Length; i++)
{

Console.WriteLine(list[i]);
}
Console.WriteLine();
}

static void Main()
{
UseParams(1, 2, 3);
UseParams2(1, 'a', "test");

// An array of objects can also be passed, as long as
// the array type matches the method being called.
int[] myarray = new int[3] {10,11,12};
UseParams(myarray);
}
}

复制代码
1
2
3

1
a
test

10
11
12

typeof（C# 参考）
示例 请参见 发送反馈意见


用于获取类型的 System.Type 对象。typeof 表达式采用以下形式：

复制代码
System.Type type = typeof(int);


备注
若要获取表达式的运行时类型，可以使用 .NET Framework 方法 GetType，如以下示例中所示：

复制代码
int i = 0;
System.Type type = i.GetType();


不能重载 typeof 运算符。

typeof 运算符也能用于公开的泛型类型。具有不止一个类型参数的类型的规范中必须有适当数量的逗号。下面的示例演示如何确定方法的返回类型是否是泛型 IEnumerable<(Of <(T>)>)。假定此方法是 MethodInfo 类型的实例：

复制代码
string s = method.ReturnType.GetInterface
(typeof(System.Collections.Generic.IEnumerable<>).FullName


示例
复制代码
// cs_operator_typeof.cs
using System;
using System.Reflection;

public class SampleClass
{
public int sampleMember;
public void SampleMethod() {}

static void Main()
{
Type t = typeof(SampleClass);
// Alternatively, you could use
// SampleClass obj = new SampleClass();
// Type t = obj.GetType();

Console.WriteLine("Methods:");
MethodInfo[] methodInfo = t.GetMethods();

foreach (MethodInfo mInfo in methodInfo)
Console.WriteLine(mInfo.ToString());

Console.WriteLine("Members:");
MemberInfo[] memberInfo = t.GetMembers();

foreach (MemberInfo mInfo in memberInfo)
Console.WriteLine(mInfo.ToString());
}
}

复制代码
Methods:
Void SampleMethod()
System.Type GetType()
System.String ToString()
Boolean Equals(System.Object)
Int32 GetHashCode()
Members:
Void SampleMethod()
System.Type GetType()
System.String ToString()
Boolean Equals(System.Object)
Int32 GetHashCode()
Void .ctor()
Int32 sampleMember


此示例使用 GetType 方法确定用来包含数值计算的结果的类型。这取决于结果数字的存储要求。

复制代码
// cs_operator_typeof2.cs
using System;
class GetTypeTest
{
static void Main()
{
int radius = 3;
Console.WriteLine("Area = {0}", radius * radius * Math.PI);
Console.WriteLine("The type is {0}",
(radius * radius * Math.PI).GetType()
);
}
}

复制代码
Area = 28.2743338823081
The type is System.Double


C# 语言规范
有关更多信息，请参见 C# 语言规范中的以下各

章节：

7.5.11 typeof 运算符
try-catch 语句由一个 try 块后跟一个或多个 catch 子句构成，这些子句指定不同的异常处理程序。

备注
try 块包含可能导致异常的保护代码。该块一直执行到引发异常或成功完成为止。例如，下列强制转换 null 对象的尝试引发 NullReferenceException 异常：

复制代码
object o2 = null;
try
{
int i2 = (int)o2; // Error
}


catch 子句使用时可以不带任何参数，这种情况下它捕获任何类型的异常，并被称为一般 catch 子句。它还可以接受从 System..::.Exception 派生的对象参数，这种情况下它处理特定的异常。例如：

复制代码
catch (InvalidCastException e)
{
}


在同一个 try-catch 语句中可以使用一个以上的特定 catch 子句。这种情况下 catch 子句的顺序很重要，因为会按顺序检查 catch 子句。将先捕获特定程度较高的异常，而不是特定程度较小的异常。

在 catch 块中可以使用 throw 语句再次引发已由 catch 语句捕获的异常。例如：

复制代码
catch (InvalidCastException e)
{
throw (e); // Rethrowing exception e
}


如果要再次引发当前由无参数的 catch 子句处理的异常，则使用不带参数的 throw 语句。例如：

复制代码
catch
{
throw;
}


在 try 块内部时应该只初始化其中声明的变量；否则，完成该块的执行前可能发生异常。例如，在下面的代码示例中，变量 x 在 try 块内初始化。试图在 Write(x) 语句中的 try 块外部使用此变量时将产生编译器错误：使用了未赋值的局部变量。

复制代码
static void Main()
{
int x;
try
{
// Don't initialize this variable here.
x = 123;
}
catch
{
}
// Error: Use of unassigned local variable 'x'.
Console.Write(x);
}


有关 catch 的更多信息，请参见 try-catch-finally。

示例
在此例中，try 块包含对可能导致异常的 ProcessString 方法的调用。catch 子句包含仅在屏幕上显示消息的异常处理程序。当从 MyMethod 内部调用 throw 语句时，系统查找 catch 语句并显示 Exception caught 消息。

复制代码
// try_catch_example.cs
using System;
class MainClass
{
static void ProcessString(string s)
{
if (s == null)
{
throw new ArgumentNullException();
}
}

static void Main()
{
try
{
string s = null;
ProcessString(s);
}
catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
}
}
}

复制代码
System.ArgumentNullException: Value cannot be null.
at MainClass.Main() Exception caught.


此例使用了两个 catch 语句。最先出现的最特定的异常被捕获。