C#关键字整理
一、基本关键字
1. abstract
用法：用来修饰类、方法和属性。
例子：修饰方法：public abstract void MyMethod();
修饰类：abstractclass BaseClass{};
2. as
用法：使用as运算符执行转换的某些类型在兼容之间的引用类型或可以为null的类型。
例子：class Base{};
classDerived ：Base{}
Derived d =new Derived();
Base b = das Base;
If (b !=null)
Console.WriteLine(b.ToString());
3. base
用法：用于从派生类中访问基类的成员
例子：class A：class B{
publicvoid GetInfo(){
base.GetInfo(); //假定基类B中有GetInfo方法。
}
}
4. bool
用法：用于声明变量累存储布尔值true和false。
例子：bool a = false;
5. break
用法：用于终止最近的封闭循环或它所在的switch语句，控制传递给终止语句或它后面的语句。
例子：if(x != 0) break;
6. byte
用法：表示一种整型，该类型表示的范围为0-255.
例子：byte myByte = 255;
7. case
用法：在switch语句中的用例标签（例如：case 1）。
例子：int caseSwitch = 1;
switch(caseSwitch){
case1:
Console.WriteLine(“Case1”); break;
}
8. catch
用法：捕获程序出现的异常信息。
例子：object 02 = null;
try{
inti2 = (int)o2; //error
}catch(InvalidCastExceptione){
}
9. char
用法：用于声明.NET framework使用Unicode字符表示System.Char结构的实例。
实例：char[] chars = new char[4];
10. checked
用法：用于对整型算数运算和转换显示启用溢出检查。
实例：int ten = 10;
checked{
inti2 = 21474836457 + ten;
}
11. class
用法：用于类的声明。
实例：class Test{}
12. const
用法：声明一个常量字段或局部常量。
实例：const int x = 0;
13. continue
用法：将控制传递到封闭的循环的下一次迭代。
实例：for(int i = 1; I <= 10; i++){
if(i == 5)
continue;
}
14. decimal
用法：表示128位数据类型。范围为(-7.9 x 1028 - 7.9 x 1028) / (100- 28)。
实例：decimal myMoney = 300.5m;
15. default
用法：在switch语句中指定默认标签。
实例：switch(var){
…
default:
Console.WriteLine(“hello”);
}
16. delegate
用法：委托类型的声明和方法的签名相似，有一个返回值和任意数目任意类型的参数。
实例：public delegate void TestDelegate(string message);
17. do
用法：do语句重复执行一个语句或语句块，直到指定的表达式计算为false值。
实例：int x = 0;
do{
x++
}while(x< 5);
18. double
用法：表示存储64位浮点值的简单类型。
实例：double x = 3D;
19. else
用法：用于条件的选择，和if相对立。
实例：if(condition){
Console.WriteLine(“Condition1”);
}else{
Console.WriteLine(“Condition2”);
}
20. enum
用法：用于声明枚举。
实例：enum Days{Sat, Sun, Mon, Tue, Wed, Thu, Fri};
21. event
用法：用于在发行者类中声明事件。
实例：public class Publisher{
publicevent SampleEventHander();
}
22. explicit
用法：用于声明必须使用强制转换来调用的用户定义的类型转换运算符。
实例：public static explicit operator Celsius(Object o){}
23. extern
用法：用于声明在外部实现的方法。
实例：private static extern void AVIFileInit();
24. false
用法：表示条件为假。
实例：if(x == false){
Console.WriteLine(“False”);
}
25. finally
用法：清理try中分配的任何资源，而且，即使在try中发生异常，也可以运行代码。
实例：try{
…
}finally{
Console.WriteLine(“finally”);
}
26. fixed
用法：fixed语句禁止垃圾回收器重定位可移动的变量。fixed语句只在不安全的上下文中是允许的。fixed还可用于创建固定大小的缓冲区。
实例：unsafe static void TestMethod(){
Point pt =new Point();
fixed(int*p = &pt.x){
*p= 1;
}
}
27. float
用法：表示存储32位浮点值的简单类型。
实例：float x = 3.5F;
28. for
用法：使用for循环，可以反复运行语句或语句块，直到指定的表达式计算为false。
实例：for(int i = 0; i < 10; i++){
Console.WriteLine(i);
}
29. foreach
用法：foreach语句对实现System.Clooections.IEnumerable或System.Collections.
Generic.IEnumerable<T>接口的数组或对象集合的每个元素重复一组嵌入式语句。
实例：int[] array = new int[]{1,2,3,4,5};
foreach(inte in array){
System.Console.WriteLine(e);
}
30. goto
用法：goto语句将程序控制直接传递给标记语句。
实例：int[] array = new int[]{1,2,3,4,5};
foreach(inte in array){
if(e == 3)
gotoFound;
}
Found:
System.Console.WriteLine(“Foundit”);
31. if
用法：运行的语句根据Boolean表达式的值if语句标识。
实例：bool condition = true;
if(conditioni)
Console.WriteLine(“True”);
32. implicit
用法：用于声明隐式的用户定义类型转换运算符。如果可以确保转换过程不会造成数据丢失，则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。
实例：class Digit{
publicDigit(double d){ val = d;}
publicdouble val;
publicstatic implicit operator double(Digit d){
returnd.val;
}
}
33. in
用法：用于遍历一个集合。
实例：int[] array = new int[]{1,2,3,4,5};
foreach(inte in array){
System.Console.WriteLine(e);
}
34. in(泛型修饰符)
用法：对于泛型类型参数，in关键字指定该类型参数是逆变的。可以在泛型接口和委托中使用in关键字。
实例：interface Icont<in A>{}
35. int
用法：表示一种整型。
实例：int I = 100;
36. interface
用法：接口只包含方法、属性、事件或索引器的签名。
实例：interface ISampleInterface{
voidSampleMethod();
}
37. internal
用法：internal关键字是类型或类型的成员的访问修饰符。只有在同一程序集的文件中，内部类型或成员才是可访问的。
实例：public class BaseClass{
internalstatic int x = 0;
}
38. is
用法：检查对象是否与给定的类型兼容。
实例：class Class1{}
classClass2 ： Class1{}
classIsTest{
staticvoid Test(Object o)
Class1a;
Class2b;
if(ois Class1){
Console.WriteLine(“ois Class1”);
a= (Class1)o;
}
}
39. lock
用法：lock关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，饭后释放该锁。
实例：class Account
{
decimalbalance;
privateObject thisLock = new Object();
public voidWithdraw(decimal amount)
{
lock(thisLock)
{
if(amount > balance)
{
throw new Exception("Insufficient funds");
}
balance -= amount;
}
}
}
40. long
用法：表示一种整型。
实例：long long1 = 1234;
41. namespace
用法：用于声明一组相对对象的大小。
实例：namespace Sample{
classSampleClass{}
}
42. new
用法：可作为运算符、修饰符或约束。
实例：int[] a = new int[100];
43. null
用法：表示不引用任何对象的null引用的文字值。
实例：class Sample{}
Sample s =null;
44. object
用法：所有类型都继承至Object，可以将任何类型的值赋值给object类型的变量。
实例：object a;
a = 1;
45. operator
用法：使用operator关键字来重载内置运算符，或提供类或结构声明中的用户定义转换。
实例：class Fraction
{
int num, den;
publicFraction(int num, int den)
{
this.num= num;
this.den= den;
}
public staticFraction operator +(Fraction a, Fraction b)
{
returnnew Fraction(a.num * b.den + b.num * a.den,
a.den* b.den);
}
}
46. out
用法：作为参数列表中的参数修饰符
实例：
47. out(泛型修饰符)
用法：对于泛型类型参数，out关键字指定该类型参数是协变的。
实例：interface ICovariant<out R>{}
48. override
用法：要扩展或修改继承的方法，属性、索引器或事件的抽象实现或虚实现。
实例：class Test{
protecteddecimal basepay;
public virtual decimal CalculatePay(){
returnbasepay;
}
}
public class Derived : Test{
privatedecimal a;
publicoverride decimal CalculatePay(){
returna + basepay;
}
}
49. params
用法：使用params关键字可以指定采用数目可变的参数的方法参数。
实例：public static void Use(params int[] list){
for (int I= 0; I < list.Length; i++)
Console.WriteLine(i);
}
50. private
用法：用于修饰成员属性。被private修饰的成员只能在本类中访问。
实例：class Employee{
private inti;
double d;
}
51. protected
用法：该关键字是一个成员访问修饰符。收保护的成员在其所在的类中可由派生类实例访问。
实例：class A{
protectedint x = 123;
}
52. public
用法：该关键字是类型和类型成员的访问修饰符。公共访问是允许的最高访问级别。
实例：class A{
public intx = 123;
}
53. readonly
用法：readonly是可以再字段上使用的修饰符，当字段声明包括 readonly 修饰符时，该声明引入的字段赋值只能作为声明的一部分出现，或者出现在同一类的构造函数中。
实例：class Age
{
readonly int_year;
Age(int year)
{
_year =year;
}
voidChangeYear()
{
//_year =1967;
}
}
54. ref
用法：ref关键字会导致通过引用传递的参数，而不是值。
实例：class Ref{
static voidMethod(ref int i){
i= i + 1;
}
}
55. return
用法：return 语句终止它出现在其中的方法的执行并将控制返回给调用者。
实例：double getYear(){
returnyear;
}
56. sbyte
用法：表示一种整型，其范围为-128~127.
实例：sbyte i = 123;
57. sealed
用法：当对一个类用用sealed修饰时，此修饰符会阻止其他类从该类继承。
实例：class A{}
sealedclass B : A{} //任何类都不能从B继承
58. short
用法：表示一种整数数据类型。范围为-32768~32767.
实例：short x = 100;
59. sizeof
用法：用于获取非托管类型的大小。
实例：int intSize = sizeof(int);
60. stackalloc
用法：用于不安全的代码上下文中。以便在堆栈上分配内存块。
实例：int* block = stackalloc int[100];
61. static
用法：声明属于类型本身而不是属于特定对象的静态成员。 static 修饰符可用于类、字段、方法、属性、运算符、事件和构造函数，但不能用于索引器、析构函数或类以外的类型。
实例：static class CompanyEmployee
{
public staticvoid DoSomething() { /*...*/ }
public staticvoid DoSomethingElse() { /*...*/ }
}
62. string
用法：表示一个字符序列。
实例：string a = “hello”;
63. struct
用法：该类型是一种值类型，通常用来封装小型相关变量组。
实例：public struct Book
{
public decimal price;
public string title;
public string author;
}
64. switch
用法：switch语句是一个控制语句，选择”开关部分”从候选列表中执行。
实例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;
}
65. this
用法：this关键字引用类的当前实例，还可以作扩展方法的第一个参数的修饰符。
实例：public Employee(string name, string alias)
{
this.name = name;
this.alias =alias;
}
66. throw
用法：throw 语句用于发出在程序执行期间出现反常情况（异常）的信号。
实例：class MyException : System.Exception {}
throw new MyException();
67. true
用法：用于条件判断，表示真的情形。
实例：bool flag = true;
if (flag) …
68. try
用法：try-catch 语句由一个 try 块后跟一个或多个 catch 子句构成，这些子句指定不同的异常处理程序。
实例：object o2 = null;
try
{
int i2 = (int)o2; // Error
}
69. typeof
用法：用于获取类型的 System.Type 对象。
实例：System.Type type = typeof(int);
70. uint
用法：表示一种整型。范围为0 到 4,294,967,295。
实例：uint myUint = 4294967290;
71. ulong
用法：表示一种整型。
实例：ulong ul = 10000000;
72. unchecke
用法：用于取消整型算术运算和转换的溢出检查。
实例：unchecked{
int1 = 2147483647+ 10;
}
int1 = unchecked(constantMax + 10);
73. unsafe
用法：表示不安全上下文，该上下文是任何涉及指针的操作所必须的。
实例：unsafe static void FastCopy(byte[] src, byte[] dst, int count)
{
// Unsafecontext: can use pointers here.
}
74. ushort
用法：表示一种整型数据类型，其范围为0~65535.
实例：ushort m = 65535;
75. using
用法：①作为指令，用于为命名空间创建别名或导入其他命名空间中定义的类型。②作为语句，用于定义一个范围，在此范围的末尾将释放对象。
实例：using System.Text;
76. virtual
用法：用于修饰方法、属性、索引器或事件的声明，并使他们可以在派生类中被重写。
实例：public virtual double Area(){
returnx*y;
}
77. void
用法：指定方法不返回值。
实例：public void Sample(){
//no returnvalue
}
78. volatile
用法：volatile关键字指示一个字段可以由多个同时执行的线程修改。
实例： class VolatileTest
{
publicvolatile int i;
public voidTest(int _i)
{
i = _i;
}
}
79. while
用法：while语句执行一个语句或语句块，直到指定的表达式计算为false。
实例：while(n < 5){
Console.WriteLine(n);
n++;
}
二、上下文关键字
1. add
用法：用于定义一个自定义事件访问器，当客户端代码订阅您的事件时将调用该访问器。如果提供自定义add访问器，还必须提供remove访问器。
实例：class Events : IDrawingObject
{
eventEventHandler PreDrawEvent;
eventEventHandler IDrawingObject.OnDraw
{
add
{
lock(PreDrawEvent)
{
PreDrawEvent += value;
}
}
remove
{
lock(PreDrawEvent)
{
PreDrawEvent -= value;
}
}
}
}
2. alias
用法：外部别名。可能必须引用两个具有相同完全限定类型名的程序集版本。
实例：若要引用两个具有完全限定类型名的程序集，必须在命令提示符下指定别名。如：
/r:GridV1 = grid.dll
/r:GridV2 = grid20.dll
这将创建外部别名GridV1和GridV2。若要从程序中使用这些别名，请使用extern关键字引用它们。
extern alias GridV1;
extern alias GridV2;
3. ascending
用法：用在查询表达式的orderby子句中，用于指定从最小到最大的排序顺序。
实例：IEnumerable<string> sortAscendingQuery =
from vegetable invegetables
orderby vegetableascending
select vegetable;
4. asyn
用法：可指定方法，lambda表达式或匿名方法进行同步。如果对方法或表达式使用修饰符，则其称为异步方法。
实例：public async Task<int> ExampleMethodAsync(){
//…
}
5. await
用法：await运算符应用于一个异步方法中的任务以挂起该方法的执行，直到等待的任务完成。表示正在进行的工作的任务。
使用await的异步方法必须由异步关键字修改，由使用async修饰符定义且通常包含一个或多个await表达式的此类方法为异步方法。
实例：private async Task SumPageSizeAsync(){
HttpClientclient = new HttpClient();
Task<byte[]>getContentsTask = client.GetByteArrayAsync(url);
byte[] urlContents= await getContentsTask;
}
6. descending
用法：用在查询表达式的orderby子句中，用于指定从最大到最小的排序顺序。
实例：IEnumerable<string> sortDescendingQuery =
from vegetable invegetables
orderby vegetabledescending
select vegetable;
7. dynamic
用法：在通过dynamic类型实现的操作中，该类型的作用是绕过编译时类型检查，改为运行时解析这些操作。
实例：class Program{
static voidMain(string[] args){
dynamicdyn = 1;
objectobj = 1;
System.Console.WriteLine(dyn.GetType());
System.Console.WriteLine(obj.GetType());
}
}
8. 源
用法：查询表达式必须以from子句开头。另外，查询表达式还可以包含子查询，子查询也是以from子句开头的。
实例：var lowNums = from num in numbers where num < 5 select num;
9. get
用法：get关键字在属性或索引器中定义访问器方法，以检索该属性或该索引器元素的值。
实例：class TimePeriod{
privatedouble _seconds;
publicdouble Second{
get{return _seconds;}
set{_seconds = value;}
}
}
10. global
用法：在::运算符前面使用的global上下文关键字引用全局命名空间。
实例：class TestClass : global::TestApp{}
11. group
用法：group子句返回一个IGrouping<TKey, TElement>对象序列，这些对象包含零个或更多个与该组的键值匹配的项。
实例：var studentQ1 = from student in students group student bystudent.Last[0];
12. into
用法：使用into关键字创建一个零时标记符，以便将group、join或select子句的结果存储到新的标识符中。
实例：// Create a data source.
string[]words = { "apples", "blueberries", "oranges","bananas", "apricots"};
// Create thequery.
varwordGroups1 =
from w inwords
group wby w[0] into fruitGroup
wherefruitGroup.Count() >= 2
selectnew { FirstLetter = fruitGroup.Key, Words = fruitGroup.Count() };
13. join
用法：使用join子句可以将来自不同源序列并且在对象模型中没有直接关系的元素相关联。
实例：var innerJoinQuery =
from category incategories
join prod inproducts on category.ID equals prod.CategoryID
select new {ProductName = prod.Name, Category = category.Name }; //produces flat sequence
14. let
用法：在查询表达式中，存储子表达式的结果有时很有用，这样可以在随后的子句中使用。可以用let关键字完成这一工作。
实例：string[] strings =
{
"Apenny saved is a penny earned.",
"Theearly bird catches the worm.",
"Thepen is mightier than the sword."
};
varearlyBirdQuery =
fromsentence in strings
let words = sentence.Split(' ')
from wordin words
let w =word.ToLower()
wherew[0] == 'a' || w[0] == 'e'
||w[0] == 'i' || w[0] == 'o'
||w[0] == 'u'
selectword;
15. orderby
用法：在查询表达式中，orderby子句可使返回的序列或子序列按升序或降序排序。
实例：form fruit in fruits orderby fruit select fruit;
16. partial(类型)
用法：分部类型定义允许将类、结构或接口的定义拆分到多个文件中。
实例：partial class A{
int num =0;
voidMethodA(){}
partialvoid MethodC();
}
17. partial(方法)
用法：分部方法在分部类型的一个部分中定义它的签名，并在该类型的另一个部分中定义它的实现。
实例：partial class A
{
partial voidOnSomethingHappened(string s);
}
// This part canbe in a separate file.
partial class A
{
partial voidOnSomethingHappened(String s)
{
Console.WriteLine("Something happened: {0}", s);
}
}
18. remove
用法：remove上下文关键字用于定义一个自定义事件访问器，当客户端代码取消订阅事件时将调用访问器。
实例：add
{
lock(PreDrawEvent)
{
PreDrawEvent += value;
}
}
remove
{
lock(PreDrawEvent)
{
PreDrawEvent -= value;
}
}
19. select
用法：在查询表达式中，select子句可以指定将在执行查询时产生的值的类型。
实例：from score in scores where score > 80 select score;
20. set
用法：set关键字在属性或索引器中定义为该属性或索引器元素赋值的访问器方法。
实例：class TimePeriod
{
private double_seconds;
public doubleSeconds
{
get { return_seconds; }
set {_seconds = value; }
}
}
21. value
用法：用在普通属性声明的set访问器中。此关键字类似于方法的输入参数。关键字value引用客户端代码尝试赋值给属性的值。
实例：class TimePeriod
{
private double_seconds;
public doubleSeconds
{
get { return_seconds; }
set {_seconds = value; }
}
}
22. var
用法：在方法范围中声明的变量可以具有隐式类型var。隐式类型的本地变量是强类型变量，但由编译器确定类型。
实例：var i = 10; //implicitlytyped
int i = 10; //explicitly typed
23. where(泛型类型约束)
用法：在泛型类型定义中，where子句用于指定对下列类型的约束，这些类型可用作泛型声明中定义的类型参数的实参。
实例：public class MyGenericClass<T> where T:IComparable{}
24. where(查询子句)
用法：where子句用在查询表达式中，用于指定将在查询表达式中返回数据源中的哪些元素。
实例：var queryLowNums = from num in numbers where num < 5 select num;
25. yield
用法：在语句中使用yield关键字，则指示在的方案、运算符或get访问器是迭代器。使用的迭代器对集合的自定义迭代。
实例：yield return <expression>;
yieldbreak;
扫一扫
5600
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
