virtual、override、static、abstract、sealed、extern、partial、
new
对于一个方法，C#规定只能使用下面这些限定符中的一个： (青色的除外，可以和其他限定结合使用)
override virtual static abstract sealed partial extern new
代表的含义分别为：
重载函数、虚拟函数、静态函数、抽象函数、密封函数（不可派生)、分部的、外部定义、隐藏基类
另外，C#中定义一个方法的声明为：
可见性 类型 返回值 方法名（参数列表）{方法体}
若有返回值，方法体中必须包含return语句，返回一个值，如：
public virtual string Hello(string arge)
[c-sharp]
view plain copyprint?public virtual string Hello(string ages)
{
//...
return ages;
}
若没有返回值，则使用void声明一个函数。如：
public virtual void Hello(string arge)
{}
-------------------------------------------------------------------
virtual:
virtual关键字表明这个成员可以在派生类中被重写。virtual可应用于方法，属性，索引器和事件。virtual方法不仅可以在派生类中重写，而且在所有的了类中都可以被重写。
声明为virtual的方法被重写时，派生类中可以使用base关键字访问父类中的publid,protected成员。语法：base.member
但base关键字不能跳过类层次结构中的多个层次，子类不能访问祖父类的成员。base.base.member是非法的
[c-sharp]
view plain copyprint?public class test
{
public virtual void Hello()
{
Console.WriteLine("test hello");
}
}
public class test1 : test
{
//在子类中重写Hello方法
public override void Hello()
{
Console.WriteLine("test1 hello");
}
}
public class test2 : test1
{
//在子类的子类中重写hello()方法
public override void Hello()
{
//继承的是父类test1中的Hello方法，而不是test中的Hello
base.Hello();
}
static void Main()
{
test2 test = new test2();
test.Hello(); //输出的是test1 hello，而不是test hello
}
}
override：
override关键字表示要重写基类虚拟成员的意图。要重写虚方法或抽象方法，必须声明使用override关键字。
“要扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现，必须使用 override 修饰符
override 方法提供从基类继承的成员的新实现。 由 override 声明重写的方法称为重写基方法。 重写的基方法必须与 override 方法具有相同的签名。 有关继承的信息，请参见。
不能重写非虚方法或静态方法。 重写的基方法必须是 virtual、abstract 或 override 的。
override 声明不能更改 virtual 方法的可访问性。 override 方法和 virtual 方法必须具有相同的访问级别修饰符。
您不能使用 new、static 或 virtual 修饰符来修改 override 方法。
重写属性声明必须指定与继承属性完全相同的访问修饰符、类型和名称，并且被重写的属性必须是 virtual、abstract 或 override 的。”
------MSDN
static:
当一个方法被声明为Static时，这个方法是一个静态方法，编译器会在编译时保留这个方法的实现。也就是说，这个方法属于类，但是不属于任何成员，不管这个类的实例是否存在，它们都会存在。就像入口函数Static void Main，因为它是静态函数，所以可以直接被调用。
使用static关键字的方法可以不用实例化而直接使用。
abstract:
abstract 修饰符指示所修饰的内容缺少实现或未完全实现。 abstract 修饰符可用于类、方法、属性、索引器和事件。 在类声明中使用 abstract 修饰符以指示某个类只能是其他类的基类。 标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。
抽象类的在在主要是为了继承，不能创建抽象类的实例。
包含一个或多个抽象成员的类必定也是抽象的。
抽象函数不能有函数体，例如：public abstract void Hello() {} 的声明是错误的，应为public abstract void Hello();
在此例中，类 Square 必须提供 Area 的实现，因为它派生自 ShapesClass
[c-sharp]
view plain copyprint?abstract class ShapesClass
{
abstract public int Area();
}
class Square : ShapesClass
{
int side = 0;
public Square(int n)
{
side = n;
}
// Area method is required to avoid
// a compile-time error.
public override int Area()
{
return side * side;
}
static void Main()
{
Square sq = new Square(12);
Console.WriteLine("Area of the square = {0}", sq.Area());
}
interface I
{
void M();
}
abstract class C : I
{
public abstract void M();
}
}
// Output: Area of the square = 144
sealed:
sealed 修饰符可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法，但其本身不能在任何派生类中进一步重写。当应用于方法或属性时，sealed 修饰符必须始终与override一起使用。
在下面的示例中，Z 从 Y 继承，但 Z 无法重写在 X 中声明并在 Y 中密封的虚函数 F。
[c-sharp]
view plain copyprint?class X
{
protected virtual void F() { Console.WriteLine("X.F"); }
protected virtual void F2() { Console.WriteLine("X.F2"); }
}
class Y : X
{
sealed protected override void F() { Console.WriteLine("Y.F"); }
protected override void F2() { Console.WriteLine("X.F3"); }
}
class Z : Y
{
// Attempting to override F causes compiler error CS0239.
// protected override void F() { Console.WriteLine("C.F"); }
// Overriding F2 is allowed.
protected override void F2() { Console.WriteLine("Z.F2"); }
}
虚函数与抽象函数的区别：简单来说虚函数（Virtual）已经包含了也必须包含默认的实现，所以在派生类中可以重新实现也可以不实现这些虚函数。抽象函数（abstract）没有提供默认实现，所以在派生类中必须实现这些抽象函数。
partial
部分方法也可以是静态的，但它们总是私有的，且不能有返回值。它们使用的任何参数都不能是out 参数，但可以是ref 参数。部分方法也不能使用virtual、abstract、override、new、sealed 和extern修饰符。
考虑下面的代码：
public partial class MyClass
{
partial void DoSomethingElse();
public void DoSomething()
{
Console.WriteLine("DoSomething() execution started.");
DoSomethingElse();
Console.WriteLine("DoSomething() execution finished.");
}
}
public partial class MyClass
{
partial void DoSomethingElse()
{
Console.WriteLine("DoSomethingElse() called.");
}
}
在第一个部分类定义中定义和调用部分方法DoSomethingElse，在第二个部分类中实现它。在
控制台应用程序中调用DoSomething 时，输出如下内容：
DoSomething() execution started.
DoSomethingElse() called.
DoSomething() execution finished.
如果删除第二个部分类定义，或者删除部分方法的全部执行代码(注释掉代码)，输出就如下
所示：
DoSomething() execution started.
DoSomething() execution finished.
读者可能认为，调用DoSomethingElse 时，运行库发现该方法没有实现代码，因此会继续执行下一行代码。但实际上，编译代码时，如果代码包含一个没有实现代码的部份方法，编译器会完全删除该方法，还会删除对该方法的所有调用。执行代码时，不会检查实现代码，因为没有检查方法的调用。这会略微提高性能。与部分类一样，在定制自动生成的代码或设计器创建的代码时，部分方法是很有用的。设计器会声明部分方法，用户根据具体情形选择是否实现它。如果不实现它，就不会影响性能，因为该方法在编译过的代码中不存在。现在考虑为什么部分方法不能有返回类型。如果可以回答这个问题，就可以确保完全理解了这个主题，我们将此留作练习。
extern
new
new 放在字段、属性、方法前面是用来隐藏，继承的基类或者实现的接口中的同名的字段、属性、方法，它与override的区别是，隐藏后，子类对象向上转型为基类在调用此类方法时依然只能执行基类的相关字段、属性、方法。
示例：
public class MyBaseClass
{
public virtual void DoSomething()
{
Console.WriteLine("Base imp");
}
}
public class MyDerivedClass : MyBaseClass
{
new public void DoSomething()
{
Console.WriteLine("Derived imp");
}
}
MyDerivedClass myObj = new MyDerivedClass();
MyBaseClass myBaseObj;
myBaseObj = myObj;
myBaseObj.DoSomething();
其结果如下：
Base imp
重写方法将替换基类中的实现代码，这样，下面的代码就将使用新版本，即使这是通过基
类类型进行的，情况也是这样(使用多态性)：
结果如下：
Derived imp
