C#中的修饰符有很多，可以分类：
类修饰符，存取修饰符，成员修饰符。
(一) 类及其类的存取修饰符有：
public，inner，friend，abastruct，sealed
1. public：
public class ClassPublic{}
如果一个类声明为public，则该类的应用不受限制。具体含义可与inner参考对比。
2. inner：
inner class ClassInner{}
如果一个类声明为inner，则该类只在程序集中可见。可以理解成在同一个dll或exe中可以应用该类，但是出了该程序集，则该类就不可见了。
例如:程序集Assm1中有一个public的类ClassPublic一个inner的类ClassInner。
在程序集Assm2中有一个类ClassTest：
class ClassTest
{
ClassPublic demo1; // 正确，因为ClassPublic类是public类型
ClassInner demo2; // 错误，因为ClassInner为inner类型，仅在:程序集Assm1中可用，出了:程序集Assm1，就看不见了。
}
3. abastruct：
abstract class ClassAbstract
{
public ClassAbstract()
{
}
}
表示ClassAbstract demo3 = new ClassAbstract();这句话通不过编译【是错误的】，因为该类是一个抽象类。
如果某个类中包含了一个抽象函数，则这个类必须是一个抽象类。
抽象函数：只有函数的声明而没有实现代码的函数。试想：如果ClassAbstract类中有个抽象函数FunctionAbstract。
demo3.FunctionAbstract()将会怎么执行？不知道怎么执行，因为FunctionAbstract函数没有实现代码。这不乱套了吗？
所以不允许new一个抽象类。
4. sealed：
sealed class ClassSealed{}
类ClassSealed的意思是不允许被继承。即：
class ClassSealedChild : ClassSealed{}是错误的。
用sealed修饰的类叫密封类。
class Class1{}
sealed class Class : Class1{}
这句话是正确的。
成员修饰符：
public, private, protected, virtual, override, abstract, sealed, static, const,readonly,
(二) 用于继承的有：
1. Public：
一个函数，变量，属性可以是public类型的，即是公共类型。类之外的函数可以调用这个成员。
例如：
Class Class1{
Public string str1;
Private string str2;
Protected string str3;
}
Class Class2
{
Private void Test()
{
Class1 demo1 = new Class1();
String strTest = demo1. str1; // 正确，因为Class1的str1为public类型
String strTest2 = demo1. str2; // 错误，因为Class1的str2为private类型
String strTest3 = demo1. str3; // 错误，因为Class1的str3为protected类型
}
}
Class Class3 : Class1
{
String strTest3 = demo1. str3; // 争取的，因为Class1的str3为protected类型，而Class3是Class1的派生类（子类）
}
2. Protected：
Protected string str3;
一个函数，变量，属性可以是Protected类型的，即是保护类型。本类及其本类的派生类可以访问。
3. private：
private string str2;
一个函数，变量，属性可以是private类型的，即是私有类型。类之外的函数不可以调用这个成员。
4. inner
inner string str3;
一个函数，变量，属性可以是inner类型的，即只有在同一个程序集中才可以访问。
5. inner protected/protected inner
inner protected string str4;
protected inner string str5;
这两个变量表示在同一个程序集或者是当前类的派生类才可以访问。
注意：这里不是指：当前类的派生类而且是在同一个程序集中。
6. virtual
virtual void Test()
{
}
虚函数，参考override修饰符。
7. abstract
abstract void Test();
abstract string TestStr{
get;set;
}
没有实现代码的函数或属性。包含抽象函数或属性的类必须是抽象类。
8. override
class Class1{
virtual void Test()
{
….
}
Void Test2()
{
Test();
}
}
class Class2 : Class1{
override void Test() // 正确，覆盖了基类虚函数
{
….
}
}
class Class3 : Class2{
override void Test() // 正确，覆盖了基类虚函数
{
….
}
}
class Class4 : Class2{
}
Class1 demo1 = new Class1();
demo1. Test2(); // Test2中调用的是Class1中的Test函数。
Class2 demo2 = new Class2();
Demo2. Test2(); // Test2中调用的是Class2中的Test函数。因为Class2重写了Class1中的Test函数
Class3 demo3 = new Class3();
Demo3. Test2(); // Test2中调用的是Class3中的Test函数。因为Class2重写了Test函数
Class4 demo4 = new Class4();
Demo4. Test2(); // Test2中调用的是Class2中的Test函数。因为Class4没有重写Test，所以它执行其父类代码。
9. sealed：
sealed可以用来秘方虚函数或抽象函数。例如：
class Class1{
virtual void Test()
{
….
}
}
class Class2 : Class1{
sealed override void Test() // 正确，覆盖了基类虚函数
{
….
}
}
class Class3 : Class2{
sealed override void Test() // 错误，因为虚函数已被Class2密封
{
….
}
}
(三) 用于声明静态变量或方法：
1. static
class Class1{
public static string StaticString;
}
C#中，静态变量/函数/属性表示可以通过类名访问的变量/函数/属性。表示该变量/函数/属性是属于类的，而不是属于对象的
Class Class2{
Class1 demo1 = new Class1();
String TestStr = Class1. StaticString; // 正确。
String TestStr2 = demo1. StaticString; // 错误，demo1中并没有StaticString这个成员
}
2. readonly
readonly可以修饰静态变量，表示该变量不可以修改。即静态只读变量。
Static Readonly与const类似。
我们可以用只实现get方法的属性类实现与Static Readonly相似的功能，但是比Static Readonly方便的地方就是属性中可以有变量。
例如：
Static string TXT = “txt”;
Static string TXT2 = TXT + “
Static string TXT3
{
Get
{
Return TXT + “
}
}
(四) 用于声明常量
1. const
class Class1{
public const string ClassName = “Class
}
常量很类似于静态只读变量。
(五) 用于委托的：
1. delegate：
public
声明一个委托，名称叫OnMoveHandler，该委托的返回类型为string，该委托的参数为string name, int id。
(六) 用于事件的：
1. event
public event OnMoveHandler OnMove;
声明一个事件，该事件的名称为OnMove，类型为OnMoveHandler。
该事件的返回类型string，参数为string name, int id
给事件赋值：
Private string MyMove(string name, int id)
{
….
}
OnMove += new OnMoveHandler(MyMove);