澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站修饰符和关键字,关键字大

2019-08-10 作者:www.8455.com   |   浏览(169)

修饰符

1, 访问修饰符

abstract
可以和类、方法、属性、索引器及事件一起使用,标识一个可以扩展但不能被实体化的、必须被实现的类或方法。
as
一个转换操作符,如果转换失败,就返回null。
base
用于访问被派生类或构造中的同名成员隐藏的基类成员。
catch
定义一个代码块,在特定类型异常抛出时,执行块内代码。参见try和finally。
checked
既是操作符又是语句。确保编译器运行时,检查整数类型操作或转换时出现的溢出。
const
标识一个可在编译时计算出来的变量值,即一经指派不可修改的值。
delegate
指定一个声明为一种委托类型。委托把方法封装为可调用实体,能在委托实体中调用。
enum
表示一个已命名常量群集的值类型。
event
允许一个类或对象提供通知的成员,他必须是委托类型。
explicit
一个定义用户自定义转换操作符的操作符,通常用来将内建类型转换为用户定义类型或反向操作。必须再转换时调用显示转换操作符。
extern
标识一个将在外部(通常不是c#语言)实现的方法。
finally
定义一个代码块,在程序控制离开try代码快后执行。参见try和catch。
fixed
在一个代码块执行时,在固定内存位置为一个变量指派一个指针。
foreach
用于遍历一个群集的元素。
goto
一个跳转语句,将程序执行重定向到一个标签语句。
implicit
一个操作符,定义一个用户定义的转换操作符。 通常用来将预定义类型转换为用户定义类型或反向操作。隐式转换操作符必须在转换时使用。
interface
将一个声明指定为接口类型,即实现类或构造必须遵循的合同。
internal
一个访问修饰符。
namespace
定义一个逻辑组的类型和命名空间。
operator
用来声明或多载一个操作符。
out
标识一个参数值会受影响的参数,但在传入方法时,该参数无需先初始化。
params
声明一个参数数组。如果使用,必须修改指定的最后一个参数。允许可选参数。
readonly
标识一个变量的值在初始化后不可修改。
ref
标识一个参数值可能会受影响的参数。
sealed
防止类型被派生,防止方法和property被覆载。
sizeof
一个操作符,以byte为单位返回一个值类型的长度。
stackalloc
返回在堆上分配的一个内存块的指针。
struct
struct是一种值类型,可以声明常量、字段、方法、property、索引器、操作符、构造器和内嵌类型。
throw
抛出一个异常。
try
异常处理代码块的组成部分之一。try代码块包括可能会抛出异常的代码。参阅catch和finally关键字。
typeof
一个操作符,返回传入参数的类型。
unchecked
禁止溢出检查。
unsafe
标注包含指针操作的代码块、方法或类。
using
当用于命名空间时,using关键字允许访问该命名空间中的类型, 而无需指定其全名。也用于定义finalization操作的范围。
virtual
一个方法修饰符,标识可被覆载的方法。
volatile
标识一个可被操作系统、某些硬件设备或并发线程修改的attribute。

abstract
可以和类、方法、属性、索引器及事件一起使用,标识一个可以扩展但不能被实体化的、必须被实现的类或方法。
as
一个转换操作符,如果转换失败,就返回null。
base
用于访问被派生类或构造中的同名成员隐藏的基类成员。
catch
定义一个代码块,在特定类型异常抛出时,执行块内代码。参见try和finally。
checked
既是操作符又是语句。确保编译器运行时,检查整数类型操作或转换时出现的溢出。
const
标识一个可在编译时计算出来的变量值,即一经指派不可修改的值。
delegate
指定一个声明为一种委托类型。委托把方法封装为可调用实体,能在委托实体中调用。
enum
表示一个已命名常量群集的值类型。
event
允许一个类或对象提供通知的成员,他必须是委托类型。
explicit
一个定义用户自定义转换操作符的操作符,通常用来将内建类型转换为用户定义类型或反向操作。必须再转换时调用显示转换操作符。
extern
标识一个将在外部(通常不是c#语言)实现的方法。
finally
定义一个代码块,在程序控制离开try代码快后执行。参见try和catch。
fixed
在一个代码块执行时,在固定内存位置为一个变量指派一个指针。
foreach
用于遍历一个群集的元素。
goto
一个跳转语句,将程序执行重定向到一个标签语句。
implicit
一个操作符,定义一个用户定义的转换操作符。 通常用来将预定义类型转换为用户定义类型或反向操作。隐式转换操作符必须在转换时使用。
interface
将一个声明指定为接口类型,即实现类或构造必须遵循的合同。
internal
一个访问修饰符。
namespace
定义一个逻辑组的类型和命名空间。
operator
用来声明或多载一个操作符。
out
标识一个参数值会受影响的参数,但在传入方法时,该参数无需先初始化。
params
声明一个参数数组。如果使用,必须修改指定的最后一个参数。允许可选参数。
readonly
标识一个变量的值在初始化后不可修改。
ref
标识一个参数值可能会受影响的参数。
sealed
防止类型被派生,防止方法和property被覆载。
sizeof
一个操作符,以byte为单位返回一个值类型的长度。
stackalloc
返回在堆上分配的一个内存块的指针。
struct
struct是一种值类型,可以声明常量、字段、方法、property、索引器、操作符、构造器和内嵌类型。
throw
抛出一个异常。
try
异常处理代码块的组成部分之一。try代码块包括可能会抛出异常的代码。参阅catch和finally关键字。
typeof
一个操作符,返回传入参数的类型。
unchecked
禁止溢出检查。
unsafe
标注包含指针操作的代码块、方法或类。
using
当用于命名空间时,using关键字允许访问该命名空间中的类型, 而无需指定其全名。也用于定义finalization操作的范围。
virtual
一个方法修饰符,标识可被覆载的方法。
volatile
标识一个可被操作系统、某些硬件设备或并发线程修改的attribute。

1, 访问修饰符

指定声明的类型和类型成员的可访问性。

sealed 修饰符表示密封用于类时,表示该类不能再被继承,不能和 abstract 同时使用,因为这两个修饰符在含义上互相排斥用于方法和属性时,表示该方法或属性不能再被继承,必须和 override 关键字一起使用,因为使用 sealed 修饰符的方法或属性肯定是基类中相应的虚成员通常用于实现第三方类库时不想被客户端继承,或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱恰当的利用 sealed 修饰符也可以提高一定的运行效率,因为不用考虑继承
abstract & virtual
abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。
在类声明中使用 abstract 修饰符以指示类只能是其他类的基类。接下来描述了abstract的一些特性:不能实例化;可以包含抽象方法和抽象访问器;不能用 sealed 修饰符修改抽象类,意味着该类不能被继承;从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实现;
在方法或属性声明中使用 abstract 修饰符以指示此方法或属性不包含实现等等。"abstract"可以修饰类、方法、属性、索引器及事件
而看到virtual关键字的时候,产生了一个疑问:"virtual"关键字只能修饰方法和属性,却不能修饰类~但清楚记得老师讲C 的时候有一个概念,叫虚基类。难道c#把virtual的这个特性去掉了?然后我到google找答案~看到了两篇文章“c 虚基类”和“深入剖析c#继承机制”,终于明白了原来是由于这两者的继承机制不同而决定的。c 允许多重继承,而c#只允许派生类从一个类中继承,由于多重继承产生的二义性问题需要虚基类来解决,所以c 有虚基类的概念,而c#由于单继承的原因不会产生继承而带来的二义性问题,

sealed 修饰符表示密封用于类时,表示该类不能再被继承,不能和 abstract 同时使用,因为这两个修饰符在含义上互相排斥用于方法和属性时,表示该方法或属性不能再被继承,必须和 override 关键字一起使用,因为使用 sealed 修饰符的方法或属性肯定是基类中相应的虚成员通常用于实现第三方类库时不想被客户端继承,或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱恰当的利用 sealed 修饰符也可以提高一定的运行效率,因为不用考虑继承
abstract & virtual
abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。
在类声明中使用 abstract 修饰符以指示类只能是其他类的基类。接下来描述了abstract的一些特性:不能实例化;可以包含抽象方法和抽象访问器;不能用 sealed 修饰符修改抽象类,意味着该类不能被继承;从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实现;
在方法或属性声明中使用 abstract 修饰符以指示此方法或属性不包含实现等等。"abstract"可以修饰类、方法、属性、索引器及事件
而看到virtual关键字的时候,产生了一个疑问:"virtual"关键字只能修饰方法和属性,却不能修饰类~但清楚记得老师讲C 的时候有一个概念,叫虚基类。难道c#把virtual的这个特性去掉了?然后我到google找答案~看到了两篇文章“c 虚基类”和“深入剖析c#继承机制”,终于明白了原来是由于这两者的继承机制不同而决定的。c 允许多重继承,而c#只允许派生类从一个类中继承,由于多重继承产生的二义性问题需要虚基类来解决,所以c 有虚基类的概念,而c#由于单继承的原因不会产生继承而带来的二义性问题,

指定声明的类型和类型成员的可访问性。

(1)     public

所以不需要virtual关键修饰类。

类型
Void 用作方法的返回类型时,void 关键字指定方法不返回值。
在方法的参数列表中不允许使用 void。采用以下形式声明一个无参数的、不返回值的方法: Ovid SampleMethod();
Var 在方法范围中声明的变量可以具有隐式类型 var。隐式类型的本地变量是强类型变量(就好像您已经声明该类型一样),但由编译器确定类型。 有返回值
引用类型
Class 类是使用关键字 class 声明的
委托类型的声明与方法签名相似,有一个返回值和任意数目任意类型的参数:
public delegate void TestDelegate(string message);
public delegate int TestDelegate(MyType m, long num);
delegate 是一种可用于封装命名或匿名方法的引用类型。委托类似于 C 中的函数指针;但是,委托是类型安全和可靠的。
接口只包含方法、属性、事件或索引器的签名。成员的实现是在实现接口的类或结构中完成的
object 类型在 .NET Framework 中是 Object 的别名。在 C# 的统一类型系统中,所有类型(预定义类型、用户定义类型、引用类型和值类型)都是直接或间接从 Object 继承的。可以将任何类型的值赋给 object 类型的变量。将值类型的变量转换为对象的过程称为“装箱”。将对象类型的变量转换为值类型的过程称为“取消装箱”。
string 类型表示零或更多 Unicode 字符组成的序列。string 是 .NET Framework 中 String 的别名。
尽管 string 是引用类型,但定义相等运算符(== 和 !=)是为了比较 string 对象(而不是引用)的值。这使得对字符串相等性的测试更为直观。
Override 要扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现,必须使用 override 修饰符。
virtual 关键字用于修饰方法、属性、索引器或事件声明,并使它们可以在派生类中被重写。例如,此方法可被任何继承它的类重写。
volatile 关键字指示一个字段可以由多个同时执行的线程修改。声明为 volatile 的字段不受编译器优化(假定由单个线程访问)的限制。这样可以确保该字段在任何时间呈现的都是最新的值。
澳门新萄京官方网站修饰符和关键字,关键字大全。unsafe 关键字表示不安全上下文,该上下文是任何涉及指针的操作所必需的。
static 使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员。static 修饰符可用于类、字段、方法、属性、运算符、事件和构造函数,但不能用于索引器、析构函数或类以外的类型。
sealed 当对一个类应用 sealed 修饰符时,此修饰符会阻止其他类从该类继承。在下面的示例中,类 B 从类 A 继承,但是任何类都不能从类 B 继承。
readonly 关键字是可以在字段上使用的修饰符。当字段声明包括 readonly 修饰符时,该声明引入的字段赋值只能作为声明的一部分出现,或者出现在同一类的构造函数中。
extern 修饰符用于声明在外部实现的方法。extern 修饰符的常见用法是在使用 Interop 服务调入非托管代码时与 DllImport 属性一起使用。在这种情况下,还必须将方法声明为 static
event 关键字用于在发行者类中声明事件。
const 关键字用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数,不能被修改。
abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。在类声明中使用 abstract 修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。
访问修饰符
internal 关键字是类型和类型成员的访问修饰符。只有在同一程序集的文件中,内部类型或成员才是可访问的
private 关键字是一个成员访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结构体中才是可访问的
protected 关键字是一个成员访问修饰符。受保护成员在其所在的类中可由派生类实例访问。
public 关键字是类型和类型成员的访问修饰符。公共访问是允许的最高访问级别。
abstract 可以和类、方法、属性、索引器及事件一起使用,
标识一个可以扩展但不能被实体化的、必须被实现的类或方法。
as 一个转换操作符,如果转换失败,就返回null。
base 用于访问被派生类或构造中的同名成员隐藏的基类成员。
catch 定义一个代码块,在特定类型异常抛出时,执行块内代码。
参见try和finally。
checked 既是操作符又是语句。
确保编译器运行时,检查整数类型操作或转换时出现的溢出。
const 标识一个可在编译时计算出来的变量值,即一经指派不可修改的值。
delegate 指定一个声明为一种委托类型。委托把方法封装为可调用实体,
能在委托实体中调用。
enum 表示一个已命名常量群集的值类型。
event 允许一个类或对象提供通知的成员,他必须是委托类型。
explicit 一个定义用户自定义转换操作符的操作符,
通常用来将内建类型转换为用户定义类型或反向操作。
必须再转换时调用显示转换操作符。
extern 标识一个将在外部(通常不是c#语言)实现的方法。
finally 定义一个代码块,在程序控制离开try代码快后执行。参见try和catch。
fixed 在一个代码块执行时,在固定内存位置为一个变量指派一个指针。
foreach 用于遍历一个群集的元素。
goto 一个跳转语句,将程序执行重定向到一个标签语句。
implicit 一个操作符,定义一个用户定义的转换操作符。
通常用来将预定义类型转换为用户定义类型或反向操作。
隐式转换操作符必须在转换时使用。
interface 将一个声明指定为接口类型,即实现类或构造必须遵循的合同。
internal 一个访问修饰符。
namespace 定义一个逻辑组的类型和命名空间。
operator 用来声明或多载一个操作符。
out 标识一个参数值会受影响的参数,但在传入方法时,
该参数无需先初始化。
params 声明一个参数数组。如果使用,必须修改指定的最后一个参数。
允许可选参数。
readonly 标识一个变量的值在初始化后不可修改。
ref 标识一个参数值可能会受影响的参数。
sealed 防止类型被派生,防止方法和property被覆载。
sizeof 一个操作符,以byte为单位返回一个值类型的长度。
stackalloc 返回在堆上分配的一个内存块的指针。
struct struct是一种值类型,可以声明常量、字段、方法、property、
索引器、操作符、构造器和内嵌类型。
throw 抛出一个异常。
try 异常处理代码块的组成部分之一。try代码块包括可能会
抛出异常的代码。参阅catch和finally关键字。
typeof 一个操作符,返回传入参数的类型。
unchecked 禁止溢出检查。
unsafe 标注包含指针操作的代码块、方法或类。
using 当用于命名空间时,using关键字允许访问该命名空间中的类型,
而无需指定其全名。也用于定义finalization操作的范围。
virtual 一个方法修饰符,标识可被覆载的方法。
volatile 标识一个可被操作系统、某些硬件设备或并发线程修改的attribute。
一般的构造函数总是public类型的,如果是private类型的,表明类不能被实例化,这通常用于只含有静态的成员的类。
在派生类中声明对虚方法的重载,要求在声明中加上override关键字,而且不能有new,static或virtual修饰符。
密封类在声明中使用sealed修饰符,这样就可以防止该类被其它类继承。

所以不需要virtual关键修饰类。

类型
Void 用作方法的返回类型时,void 关键字指定方法不返回值。
在方法的参数列表中不允许使用 void。采用以下形式声明一个无参数的、不返回值的方法: Ovid SampleMethod();
Var 在方法范围中声明的变量可以具有隐式类型 var。隐式类型的本地变量是强类型变量(就好像您已经声明该类型一样),但由编译器确定类型。 有返回值
引用类型
Class 类是使用关键字 class 声明的
委托类型的声明与方法签名相似,有一个返回值和任意数目任意类型的参数:
public delegate void TestDelegate(string message);
public delegate int TestDelegate(MyType m, long num);
delegate 是一种可用于封装命名或匿名方法的引用类型。委托类似于 C 中的函数指针;但是,委托是类型安全和可靠的。
接口只包含方法、属性、事件或索引器的签名。成员的实现是在实现接口的类或结构中完成的
object 类型在 .NET Framework 中是 Object 的别名。在 C# 的统一类型系统中,所有类型(预定义类型、用户定义类型、引用类型和值类型)都是直接或间接从 Object 继承的。可以将任何类型的值赋给 object 类型的变量。将值类型的变量转换为对象的过程称为“装箱”。将对象类型的变量转换为值类型的过程称为“取消装箱”。
string 类型表示零或更多 Unicode 字符组成的序列。string 是 .NET Framework 中 String 的别名。
尽管 string 是引用类型,但定义相等运算符(== 和 !=)是为了比较 string 对象(而不是引用)的值。这使得对字符串相等性的测试更为直观。
Override 要扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现,必须使用 override 修饰符。
virtual 关键字用于修饰方法、属性、索引器或事件声明,并使它们可以在派生类中被重写。例如,此方法可被任何继承它的类重写。
volatile 关键字指示一个字段可以由多个同时执行的线程修改。声明为 volatile 的字段不受编译器优化(假定由单个线程访问)的限制。这样可以确保该字段在任何时间呈现的都是最新的值。
unsafe 关键字表示不安全上下文,该上下文是任何涉及指针的操作所必需的。
static 使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员。static 修饰符可用于类、字段、方法、属性、运算符、事件和构造函数,但不能用于索引器、析构函数或类以外的类型。
sealed 当对一个类应用 sealed 修饰符时,此修饰符会阻止其他类从该类继承。在下面的示例中,类 B 从类 A 继承,但是任何类都不能从类 B 继承。
readonly 关键字是可以在字段上使用的修饰符。当字段声明包括 readonly 修饰符时,该声明引入的字段赋值只能作为声明的一部分出现,或者出现在同一类的构造函数中。
extern 修饰符用于声明在外部实现的方法。extern 修饰符的常见用法是在使用 Interop 服务调入非托管代码时与 DllImport 属性一起使用。在这种情况下,还必须将方法声明为 static
event 关键字用于在发行者类中声明事件。
const 关键字用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数,不能被修改。
abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。在类声明中使用 abstract 修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。
访问修饰符
internal 关键字是类型和类型成员的访问修饰符。只有在同一程序集的文件中,内部类型或成员才是可访问的
private 关键字是一个成员访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结构体中才是可访问的
protected 关键字是一个成员访问修饰符。受保护成员在其所在的类中可由派生类实例访问。
public 关键字是类型和类型成员的访问修饰符。公共访问是允许的最高访问级别。
abstract 可以和类、方法、属性、索引器及事件一起使用,
标识一个可以扩展但不能被实体化的、必须被实现的类或方法。
as 一个转换操作符,如果转换失败,就返回null。
base 用于访问被派生类或构造中的同名成员隐藏的基类成员。
catch 定义一个代码块,在特定类型异常抛出时,执行块内代码。
参见try和finally。
checked 既是操作符又是语句。
确保编译器运行时,检查整数类型操作或转换时出现的溢出。
const 标识一个可在编译时计算出来的变量值,即一经指派不可修改的值。
delegate 指定一个声明为一种委托类型。委托把方法封装为可调用实体,
能在委托实体中调用。
enum 表示一个已命名常量群集的值类型。
event 允许一个类或对象提供通知的成员,他必须是委托类型。
explicit 一个定义用户自定义转换操作符的操作符,
通常用来将内建类型转换为用户定义类型或反向操作。
必须再转换时调用显示转换操作符。
extern 标识一个将在外部(通常不是c#语言)实现的方法。
finally 定义一个代码块,在程序控制离开try代码快后执行。参见try和catch。
fixed 在一个代码块执行时,在固定内存位置为一个变量指派一个指针。
foreach 用于遍历一个群集的元素。
goto 一个跳转语句,将程序执行重定向到一个标签语句。
implicit 一个操作符,定义一个用户定义的转换操作符。
通常用来将预定义类型转换为用户定义类型或反向操作。
隐式转换操作符必须在转换时使用。
interface 将一个声明指定为接口类型,即实现类或构造必须遵循的合同。
internal 一个访问修饰符。
namespace 定义一个逻辑组的类型和命名空间。
operator 用来声明或多载一个操作符。
out 标识一个参数值会受影响的参数,但在传入方法时,
该参数无需先初始化。
params 声明一个参数数组。如果使用,必须修改指定的最后一个参数。
允许可选参数。
readonly 标识一个变量的值在初始化后不可修改。
ref 标识一个参数值可能会受影响的参数。
sealed 防止类型被派生,防止方法和property被覆载。
sizeof 一个操作符,以byte为单位返回一个值类型的长度。
stackalloc 返回在堆上分配的一个内存块的指针。
struct struct是一种值类型,可以声明常量、字段、方法、property、
索引器、操作符、构造器和内嵌类型。
throw 抛出一个异常。
try 异常处理代码块的组成部分之一。try代码块包括可能会
抛出异常的代码。参阅catch和finally关键字。
typeof 一个操作符,返回传入参数的类型。
unchecked 禁止溢出检查。
unsafe 标注包含指针操作的代码块、方法或类。
using 当用于命名空间时,using关键字允许访问该命名空间中的类型,
而无需指定其全名。也用于定义finalization操作的范围。
virtual 一个方法修饰符,标识可被覆载的方法。
volatile 标识一个可被操作系统、某些硬件设备或并发线程修改的attribute。
一般的构造函数总是public类型的,如果是private类型的,表明类不能被实例化,这通常用于只含有静态的成员的类。
在派生类中声明对虚方法的重载,要求在声明中加上override关键字,而且不能有new,static或virtual修饰符。
密封类在声明中使用sealed修饰符,这样就可以防止该类被其它类继承。

(1) public

public关键字是类型和类型成员的访问修饰符。公共访问是允许的最高访问级别。对访问公共成员没有限制。

public关键字是类型和类型成员的访问修饰符。公共访问是允许的最高访问级别。对访问公共成员没有限制。

(2)     private

(2) private

private关键字是一个成员访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结构体中才是可访问的。

private关键字是一个成员访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结构体中才是可访问的。

(3)     internal

(3) internal

internal关键字是类型和类型成员的访问修饰符。只有在同一程序集的文件中,内部类型或成员才是可访问的。

internal关键字是类型和类型成员的访问修饰符。只有在同一程序集的文件中,内部类型或成员才是可访问的。

(4)     protected

(4) protected

protected关键字是一个成员访问修饰符。受保护成员在它的类中可访问并且可由派生类访问。

protected关键字是一个成员访问修饰符。受保护成员在它的类中可访问并且可由派生类访问。

   

![](http://images2015.cnblogs.com/blog/1036033/201610/1036033-20161002134040208-529760062.jpg)

声明的可访问性

含义

public

访问不受限制。

protected

访问仅限于包含类或从包含类派生的类型。

internal

访问仅限于当前程序集。

protected internal

访问仅限于从包含类派生的当前程序集或类型。

private

访问仅限于包含类型。

2, abstract

 

指示某个类只能是其他类的基类。

2, abstract

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

指示某个类只能是其他类的基类。

3, const

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

指定无法修改字段或局部变量的值。

3, const

const关键字用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数,不能被修改。

指定无法修改字段或局部变量的值。

4, event

const关键字用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数,不能被修改。

声明事件。

4, event

类和结构使用事件将出现的可能影响对象状态的事件通知给对象。

声明事件。

5,extern

类和结构使用事件将出现的可能影响对象状态的事件通知给对象。

指示在外部实现方法。

5,extern

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

   指示在外部实现方法。

extern关键字还可以定义外部程序集别名,使得可以从单个程序集中引用同一组件的不同版本。

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

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

 extern关键字还可以定义外部程序集别名,使得可以从单个程序集中引用同一组件的不同版本。

6,new

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

从基类成员隐藏继承的成员。

6,new

在用作修饰符时,new关键字可以显式隐藏从基类继承的成员。隐藏继承的成员意味着该成 员的派生版本将替换基类版本。在不使用 new修饰符的情况下隐藏成员是允许的,但会生成警告。使用 new显式隐藏成员会取消此警告,并记录代之以派生版本这一事实。

  从基类成员隐藏继承的成员。

若要隐藏继承的成员,请使用相同名称在派生类中声明该成员,并使用 new修饰符修饰该成员。

  在用作修饰符时,new关键字可以显式隐藏从基类继承的成员。隐藏继承的成员意味着该成   员的派生版本将替换基类版本。在不使用 new修饰符的情况下隐藏成员是允许的,但会生成警告。使用 new显式隐藏成员会取消此警告,并记录代之以派生版本这一事实。

对同一成员同时使用 new和override是错误的,因为这两个修饰符在含义上相互排斥。使用 new会用同样的名称创建一个新成员并使原始成员变为隐藏的,而 override则扩展继承成员的实现。

  若要隐藏继承的成员,请使用相同名称在派生类中声明该成员,并使用 new修饰符修饰该成员。

在不隐藏继承成员的声明中使用 new修饰符将会生成警告。

   对同一成员同时使用 new和override是错误的,因为这两个修饰符在含义上相互排斥。使用 new会用同样的名称创建一个新成员并使原始成员变为隐藏的,而 override则扩展继承成员的实现。

7,override

   在不隐藏继承成员的声明中使用 new修饰符将会生成警告。

提供从基类继承的虚拟成员的新实现。

7,override

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

 提供从基类继承的虚拟成员的新实现。

8,partial

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

在整个同一程序集中定义分部类和结构。

8,partial

分部类型定义允许将类、结构或接口的定义拆分到多个文件中。

在整个同一程序集中定义分部类和结构。

9,readonly

   分部类型定义允许将类、结构或接口的定义拆分到多个文件中。

声明一个字段,该字段只能赋值为该声明的一部分或者在同一个类的构造函数中。

9,readonly

readonly关键字是可以在字段上使用的修饰符。当字段声明包括 readonly修饰符时,该声明引入的字段赋值只能作为声明的一部分出现,或者出现在同一类的构造函数中。在此示例中,字段year的值无法在ChangeYear方法中更改,即使在类构造函数中给它赋了值。

声明一个字段,该字段只能赋值为该声明的一部分或者在同一个类的构造函数中。

10,sealed

   readonly关键字是可以在字段上使用的修饰符。当字段声明包括 readonly修饰符时,该声明引入的字段赋值只能作为声明的一部分出现,或者出现在同一类的构造函数中。在此示例中,字段year的值无法在ChangeYear方法中更改,即使在类构造函数中给它赋了值。

指定类不能被继承。

10,sealed

sealed修饰符可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法,但其本身不能在任何派生类中进一步重写。当应用于方法或属性时,sealed修饰符必须始终与override一起使用。

指定类不能被继承。

在类声明中使用 sealed修饰符可防止继承此类,

sealed修饰符可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法,但其本身不能在任何派生类中进一步重写。当应用于方法或属性时,sealed修饰符必须始终与override一起使用。

11,static

在类声明中使用 sealed修饰符可防止继承此类,

声明属于类型本身而不是属于特定对象的成员。

 

使用 static修饰符声明属于类型本身而不是属于特定对象的静态成员。static修饰符可用于类、字段、方法、属性、运算符、事件和构造函数,但不能用于索引器、析构函数或类以外的类型。

11,static

12,unsafe

声明属于类型本身而不是属于特定对象的成员。

声明不安全的上下文。

    使用 static修饰符声明属于类型本身而不是属于特定对象的静态成员。static修饰符可用于类、字段、方法、属性、运算符、事件和构造函数,但不能用于索引器、析构函数或类以外的类型。

unsafe关键字表示不安全上下文,该上下文是任何涉及指针的操作所必需的。

12,unsafe

13,virtual

声明不安全的上下文。

在派生类中声明其实现可由重写成员更改的方法或访问器。

unsafe关键字表示不安全上下文,该上下文是任何涉及指针的操作所必需的。

virtual关键字用于修饰方法、属性、索引器或事件声明,并且允许在派生类中重写这些对象。

 

调用虚方法时,将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员,如果没有派生类重写该成员,则它可能是原始成员。

13,virtual

默认情况下,方法是非虚拟的。不能重写非虚方法。

在派生类中声明其实现可由重写成员更改的方法或访问器。

virtual修饰符不能与 static、abstract和 override修饰符一起使用。

virtual关键字用于修饰方法、属性、索引器或事件声明,并且允许在派生类中重写这些对象。

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

调用虚方法时,将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员,如果没有派生类重写该成员,则它可能是原始成员。

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

默认情况下,方法是非虚拟的。不能重写非虚方法。

· 通过包括使用 override修饰符的属性声明,可在派生类中重写虚拟继承属性。

virtual修饰符不能与 staticabstract和 override修饰符一起使用。

14,volatile

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

指示字段可由操作系统、硬件或并发执行线程等在程序中进行修改。

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

volatile关键字表示字段可能被多个并发执行线程修改。声明为 volatile的字段不受编译器优化(假定由单个线程访问)的限制。这样可以确保该字段在任何时间呈现的都是最新的值。

·         通过包括使用 override修饰符的属性声明,可在派生类中重写虚拟继承属性。

volatile修饰符通常用于由多个线程访问而不使用 lock 语句(C# 参考)语句对访问进行序列化的字段。有关在多线程方案中使用 volatile的示例,请参见如何:创建和终止线程(C# 编程指南)。

 

volatile关键字可应用于以下类型:

14,volatile

· 引用类型。

指示字段可由操作系统、硬件或并发执行线程等在程序中进行修改。

· 指针类型(在不安全的上下文中)。

volatile关键字表示字段可能被多个并发执行线程修改。声明为 volatile的字段不受编译器优化(假定由单个线程访问)的限制。这样可以确保该字段在任何时间呈现的都是最新的值。

· 整型,如 sbyte、byte、short、ushort、int、uint、char、float 和 bool。

volatile修饰符通常用于由多个线程访问而不使用 lock 语句(C# 参考)语句对访问进行序列化的字段。有关在多线程方案中使用 volatile的示例,请参见如何:创建和终止线程(C# 编程指南)。

· 具有整数基类型的枚举类型。

volatile关键字可应用于以下类型:

· 已知为引用类型的泛型类型参数。

·         引用类型。

· IntPtr 和 UIntPtr。

·         指针类型(在不安全的上下文中)。

所涉及的类型必须是类或结构的字段。不能将局部变量声明为 volatile。

·         整型,如 sbyte、byte、short、ushort、int、uint、char、float 和 bool。

                                    关键字

·         具有整数基类型的枚举类型。

C#关键字

·         已知为引用类型的泛型类型参数。

澳门新萄京官方网站 1

·         IntPtr 和 UIntPtr。

abstract

所涉及的类型必须是类或结构的字段。不能将局部变量声明为 volatile

可以和类、方法、属性、索引器及事件一起使用,标识一个可以扩展但不能被实体化的、必须被实现的类或方法。
as

一个转换操作符,如果转换失败,就返回null。
base

用于访问被派生类或构造中的同名成员隐藏的基类成员。
catch

定义一个代码块,在特定类型异常抛出时,执行块内代码。参见try和finally。
checked

既是操作符又是语句。确保编译器运行时,检查整数类型操作或转换时出现的溢出。
const

标识一个可在编译时计算出来的变量值,即一经指派不可修改的值。
delegate

指定一个声明为一种委托类型。委托把方法封装为可调用实体,能在委托实体中调用。
enum

表示一个已命名常量群集的值类型。
event

允许一个类或对象提供通知的成员,他必须是委托类型。
explicit

一个定义用户自定义转换操作符的操作符,通常用来将内建类型转换为用户定义类型或反向操作。必须再转换时调用显示转换操作符。
extern

标识一个将在外部(通常不是c#语言)实现的方法。

finally

定义一个代码块,在程序控制离开try代码快后执行。参见try和catch。
fixed

在一个代码块执行时,在固定内存位置为一个变量指派一个指针。
foreach

用于遍历一个群集的元素。
goto

一个跳转语句,将程序执行重定向到一个标签语句。

implicit

一个操作符,定义一个用户定义的转换操作符。 通常用来将预定义类型转换为用户定义类型或反向操作。隐式转换操作符必须在转换时使用。

interface

将一个声明指定为接口类型,即实现类或构造必须遵循的合同。

internal

一个访问修饰符。

namespace

定义一个逻辑组的类型和命名空间。

operator

用来声明或多载一个操作符。

out

标识一个参数值会受影响的参数,但在传入方法时,该参数无需先初始化。

params

声明一个参数数组。如果使用,必须修改指定的最后一个参数。允许可选参数。

readonly

标识一个变量的值在初始化后不可修改。

ref

标识一个参数值可能会受影响的参数。

sealed

防止类型被派生,防止方法和property被覆载。

sizeof

一个操作符,以byte为单位返回一个值类型的长度。

stackalloc

返回在堆上分配的一个内存块的指针。

struct

struct是一种值类型,可以声明常量、字段、方法、property、索引器、操作符、构造器和内嵌类型。

throw

抛出一个异常。

try

异常处理代码块的组成部分之一。try代码块包括可能会抛出异常的代码。参阅catch和finally关键字。

typeof

一个操作符,返回传入参数的类型。

unchecked

禁止溢出检查。

unsafe

标注包含指针操作的代码块、方法或类。

using

当用于命名空间时,using关键字允许访问该命名空间中的类型, 而无需指定其全名。也用于定义finalization操作的范围。

virtual

一个方法修饰符,标识可被覆载的方法。

volatile

标识一个可被操作系统、某些硬件设备或并发线程修改的attribute。

sealed 修饰符表示密封用于类时,表示该类不能再被继承,不能和 abstract 同时使用,因为这两个修饰符在含义上互相排斥用于方法和属性时,表示该方法或属性不能再被继承,必须和 override 关键字一起使用,因为使用 sealed 修饰符的方法或属性肯定是基类中相应的虚成员通常用于实现第三方类库时不想被客户端继承,或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱恰当的利用 sealed 修饰符也可以提高一定的运行效率,因为不用考虑继承

abstract & virtual
abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。
在类声明中使用 abstract 修饰符以指示类只能是其他类的基类。接下来描述了abstract的一些特性:不能实例化;可以包含抽象方法和抽象访问器;不能用 sealed 修饰符修改抽象类,意味着该类不能被继承;从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实现;
在方法或属性声明中使用 abstract 修饰符以指示此方法或属性不包含实现等等。"abstract"可以修饰类、方法、属性、索引器及事件
而看到virtual关键字的时候,产生了一个疑问:"virtual"关键字只能修饰方法和属性,却不能修饰类~但清楚记得老师讲C 的时候有一个概念,叫虚基类。难道c#把virtual的这个特性去掉了?然后我到google找答案~看到了两篇文章“c 虚基类”和“深入剖析c#继承机制”,终于明白了原来是由于这两者的继承机制不同而决定的。c 允许多重继承,而c#只允许派生类从一个类中继承,由于多重继承产生的二义性问题需要虚基类来解决,所以c 有虚基类的概念,而c#由于单继承的原因不会产生继承而带来的二义性问题,
所以不需要virtual关键修饰类。

申明:

非源创博文中的内容均收集自网上,若有侵权之处,请及时联络,我会在第一时间内删除.再次说声抱歉!!!

博文欢迎转载,但请给出原文连接。

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站修饰符和关键字,关键字大

关键词: