深入浅出OOP（五）: C#访问修饰符(Public/Private/Protected/Internal/Sealed/Constants)
访问修饰符(或者叫访问控制符)是面向对象语言的特性之一，用于对类、类成员函数、类成员变量进行访问控制。同时，访问控制符也是语法保留关键字，用于封装组件。
Public, Private, Protected at Class Level在创建类时，我们需要考虑类的作用域范围，如谁可访问该类，谁可访问该类成员变量，谁可访问该类成员函数。 换而言之，我们需要约束类成员的访问范围。一个简单的规则，类成员函数、类成员变量之间可以自由
访问不受约束，这里主要说的是外部的访问约束。在创建class的时候，默认的访问控制符为private。
下面做个小实验，打开Visual Studio，创建一个C#的Console应用，命名为AccessModifiers。 添加一个类，命名为Modifiers ，拷贝如下代码：
1:usingSystem;
2:
3:namespaceAccessModifiers
4:{
5:classModifiers
6:{
7:staticvoidAAA()
8:{
9:Console.WriteLine("ModifiersAAA");
10:}
11:
12:publicstaticvoidBBB()
13:{
14:Console.WriteLine("ModifiersBBB");
15:AAA();
16:}
17:}
18:
19:classProgram
20:{
21:staticvoidMain(string[]args)
22:{
23:Modifiers.BBB();
24:}
25:}
26:}
上面的代码创建了一个类Modifiers，它有2个static函数：AAA、BBB。其中BBB是public访问修饰符，在Main中调用BBB结果如下：
Modifiers BBB
Modifiers AAA
BBB被标记为public，既任何函数皆可访问和运行。AAA被标记为private，既AAA仅能被其类内函数访问，外包是无法访问的。
修改代码如下：
1:classProgram
2:{
3:staticvoidMain(string[]args)
4:{
5:Modifiers.AAA();
6:Console.ReadKey();
7:}
8:}
则运行报错：
Modifiers'AccessModifiers.Modifiers.AAA()' is inaccessible due to its protection level
下面我们对AAA进行重构，修改如下：
1:classModifiers
2:{
3:protectedstaticvoidAAA()
4:{
5:Console.WriteLine("ModifiersAAA");
6:}
7:
8:publicstaticvoidBBB()
9:{
10:Console.WriteLine("ModifiersBBB");
11:AAA();
12:}
13:}
14:
15:classProgram
16:{
17:staticvoidMain(string[]args)
18:{
19:Modifiers.AAA();
20:Console.ReadKey();
21:}
22:}
运行结果：
'AccessModifiers.Modifiers.AAA()' is inaccessible due to its protection level
既，protected修饰符的成员变量，仅能被其同类、子类访问，外部无法访问。
继承修改我们接着添加子类，来扩展这个实例：
1:classModifiersBase
2:{
3:staticvoidAAA()
4:{
5:Console.WriteLine("ModifiersBaseAAA");
6:}
7:publicstaticvoidBBB()
8:{
9:Console.WriteLine("ModifiersBaseBBB");
10:}
11:protectedstaticvoidCCC()
12:{
13:Console.WriteLine("ModifiersBaseCCC");
14:}
15:}
16:
17:classModifiersDerived:ModifiersBase
18:{
19:publicstaticvoidXXX()
20:{
21:AAA();
22:BBB();
23:CCC();
24:}
25:}
26:
27:classProgram
28:{
29:staticvoidMain(string[]args)
30:{
31:ModifiersDerived.XXX();
32:Console.ReadKey();
33:}
34:}
运行结果：
'AccessModifiers.ModifiersBase.AAA()' is inaccessible due to its protection level
原因是AAA默认为Private访问控制符，仅可在基类中访问，子类无法访问。
类级别的Internal 修饰符换另外一个场景，用Visual Studio新建一个dll类库AccessModifiersLibrary，添加一个ClassA类，标记为iternal修饰符，代码如下：
1:AccessModifiersLibrary.ClassA:
2:
3:namespaceAccessModifiersLibrary
4:{
5:internalclassClassA
6:{
7:}
8:}
编译后，会在~\AccessModifiersLibrary\bin\Debug下找到这个dll。 在Program.cs使用这个dll, 添加dll引用，添加命名空间：
1:usingAccessModifiersLibrary;
2:
3:namespaceAccessModifiers
4:{
5:classProgram
6:{
7:staticvoidMain(string[]args)
8:{
9:ClassAclassA;
10:}
11:}
12:}
编译代码，运行结果如下：
Compile time error: 'AccessModifiersLibrary.ClassA' is inaccessible due to its protection level
之所以报错，是因为internal 修饰符的作用域。internal 修饰符仅对当前程序集(dll 或 exe)内有效，因此，当class添加internal修饰符则意味着程序集外无法访问。
命名空间的修饰符我们尝试给命名空间添加修饰符，代码如下：
1:publicnamespaceAccessModifiers
2:{
3:classProgram
4:{
5:staticvoidMain(string[]args)
6:{
7:
8:}
9:}
10:}
运行报错。
Compile time error: A namespace declaration cannot have modifiers or attributes
结论，我们无法对命名空间添加修饰符，命名空间默认是public的作用域。
私有类修改如下代码：
1:namespaceAccessModifiers
2:{
3:privateclassProgram
4:{
5:staticvoidMain(string[]args)
6:{
7:
8:}
9:}
10:}
编译报错：
Compile time error: Elements defined in a namespace cannot be explicitly declared as private, protected, or protected internal
类可被修饰为public、internal，它无法被标记为protected或者private。类默认的修饰符为internal。
重构代码如下：
1:namespaceAccessModifiers
2:{
3:publicclassProgram
4:{
5:staticvoidMain(string[]args)
6:{
7:}
8:
9:publicprivatevoidMethod1()
10:{
11:
12:}
13:}
14:}
编译运行：
Compile time error: More than one protection modifier
结论，修饰符不支持嵌套。既每次仅能用一个修饰符。
Internal 类和Public成员函数重构代码：
1:namespaceAccessModifiersLibrary
2:{
3:internalclassClassA
4:{
5:publicvoidMethodClassA(){}
6:}
7:}
8:
9:usingAccessModifiersLibrary;
10:
11:namespaceAccessModifiers
12:{
13:publicclassProgram
14:{
15:publicstaticvoidMain(string[]args)
16:{
17:ClassAclassA=newClassA();
18:classA.MethodClassA();
19:}
20:}
21:}
运行结果：
'AccessModifiersLibrary.ClassA' is inaccessible due to its protection level The type 'AccessModifiersLibrary.ClassA' has no constructors defined 'AccessModifiersLibrary.ClassA' is inaccessible due to its protection level 'AccessModifiersLibrary.ClassA' does not contain a definition for 'MethodClassA' and no extension method 'MethodClassA' accepting a first argument of type 'AccessModifiersLibrary.ClassA' could be found (are you missing a using directive or an assembly reference?)
结论，类成员变量的访问控制受限于其类的修饰符，如上面例子class为internal修饰符，则该类仅能在程序集内可被访问。
Protected Internal对代码进行重构，在ClassA、ClassB、ClassC中添加如下代码：
1:namespaceAccessModifiersLibrary
2:{
3:publicclassClassA
4:{
5:protectedinternalvoidMethodClassA()
6:{
7:
8:}
9:}
10:
11:publicclassClassB:ClassA
12:{
13:protectedinternalvoidMethodClassB()
14:{
15:MethodClassA();
16:}
17:}
18:
19:publicclassClassC
20:{
21:publicvoidMethodClassC()
22:{
23:ClassAclassA=newClassA();
24:classA.MethodClassA();
25:}
26:}
27:}
28:
29:usingAccessModifiersLibrary;
30:
31:namespaceAccessModifiers
32:{
33:publicclassProgram
34:{
35:publicstaticvoidMain(string[]args)
36:{
37:ClassCclassC=newClassC();
38:classC.MethodClassC();
39:}
40:}
41:}
运行结果无错误。
结论：Protected internal 修饰符做了2件事情，protected约定类类和继承类访问控制，internal约定了只能在当前程序集中。
1:namespaceAccessModifiers
2:{
3:classAAA
4:{
5:protectedinta;
6:voidMethodAAA(AAAaaa,BBBbbb)
7:{
8:aaa.a=100;
9:bbb.a=200;
10:}
11:}
12:classBBB:AAA
13:{
14:voidMethodBBB(AAAaaa,BBBbbb)
15:{
16:aaa.a=100;
17:bbb.a=200;
18:}
19:}
20:publicclassProgram
21:{
22:publicstaticvoidMain(string[]args)
23:{
24:}
25:}
26:}
编译结果：
Cannot access protected member 'AccessModifiers.AAA.a' via a qualifier of type 'AccessModifiers.AAA'; the qualifier must be of type 'AccessModifiers.BBB' (or derived from it)
结论：AAA中定义了一个a的protected变量，其仅能在自己内部访问和继承其的子类内访问。但是，通过传参方式传入的则无法访问--这里要求是public权限。
继承中访问优先级看代码：
1:namespaceAccessModifiers
2:{
3:classAAA
4:{
5:
6:}
7:publicclassBBB:AAA
8:{
9:
10:}
11:publicclassProgram
12:{
13:publicstaticvoidMain(string[]args)
14:{
15:}
16:}
17:}
编译报错：
Compile time error: Inconsistent accessibility: base class 'AccessModifiers.AAA' is less accessible than class 'AccessModifiers.BBB'
子类不能比其基类的访问控制符作用域范围大，如上面的例子中，基类为internal，而子类为public则报错了。
去掉继承，代码重构为如下结果：
1:namespaceAccessModifiers
2:{
3:classAAA
4:{
5:
6:}
7:publicclassBBB
8:{
9:publicAAAMethodB()
10:{
11:AAAaaa=newAAA();
12:returnaaa;
13:}
14:}
15:publicclassProgram
16:{
17:publicstaticvoidMain(string[]args)
18:{
19:}
20:}
21:}
编译结果：
Inconsistent accessibility: return type 'AccessModifiers.AAA' is less accessible than method 'AccessModifiers.BBB.MethodB()'
这样也编译不通过，因为AAA为internal的访问类型，在public BBB中返回了public的AAA，则意味着在其他程序集中也可能访问AAA，这样是违法了internal修饰符原则，故编译报错。
同理，如下的代码也是一样的问题导致编译报错：
1:namespaceAccessModifiers
2:{
3:classAAA
4:{
5:
6:}
7:publicclassBBB
8:{
9:publicAAAaaa;
10:}
11:publicclassProgram
12:{
13:publicstaticvoidMain(string[]args)
14:{
15:}
16:}
17:}
如对代码做重构，去掉BBB中AAA变量的修饰，既默认为private访问修饰符，则编译没有错误了。
1:namespaceAccessModifiers
2:{
3:classAAA
4:{
5:
6:}
7:publicclassBBB
8:{
9:AAAa;
10:}
11:publicclassProgram
12:{
13:publicstaticvoidMain(string[]args)
14:{
15:}
16:}
17:}
参考MSDN中修饰符说明：
public
同一程序集中的任何其他代码或引用该程序集的其他程序集都可以访问该类型或成员。
private
只有同一类或结构中的代码可以访问该类型或成员。
protected
只有同一类或结构或者此类的派生类中的代码才可以访问的类型或成员。
internal
同一程序集中的任何代码都可以访问该类型或成员，但其他程序集中的代码不可以。
protected internal
由其声明的程序集或另一个程序集派生的类中任何代码都可访问的类型或成员。 从另一个程序集进行访问必须在类声明中发生，该类声明派生自其中声明受保护的内部元素的类，并且必须通过派生的类类型的实例发生。
同时，C#中类、枚举、结构体等修饰符规则表如下：
Sealed ClassesSealed修饰符的类，不可被其他类继承。
1:namespaceAccessModifiers
2:{
3:sealedclassAAA
4:{
5:
6:}
7:classBBB:AAA
8:{
9:
10:}
11:publicclassProgram
12:{
13:publicstaticvoidMain(string[]args)
14:{
15:}
16:}
17:}
运行报错：
'AccessModifiers.BBB': cannot derive from sealed type 'AccessModifiers.AAA'
Sealed类使用如下：
1:usingSystem;
2:
3:namespaceAccessModifiers
4:{
5:sealedclassAAA
6:{
7:publicintx=100;
8:publicvoidMethodA()
9:{
10:Console.WriteLine("MethodAinsealedclass");
11:}
12:}
13:publicclassProgram
14:{
15:publicstaticvoidMain(string[]args)
16:{
17:AAAaaa=newAAA();
18:Console.WriteLine(aaa.x);
19:aaa.MethodA();
20:Console.ReadKey();
21:}
22:}
23:}
运行正常。
Constants1:publicclassProgram
2:{
3:privateconstintx=100;
4:publicstaticvoidMain(string[]args)
5:{
6:Console.WriteLine(x);
7:Console.ReadKey();
8:}
9:}
运行结果：
100
结论，Const变量在初始化的时候设定了初始值，可被使用，但不可修改值。同时const变量支持互相引用运算。
1:usingSystem;
2:
3:namespaceAccessModifiers
4:{
5:publicclassProgram
6:{
7:privateconstintx=y+100;
8:privateconstinty=z-10;
9:privateconstintz=300;
10:
11:publicstaticvoidMain(string[]args)
12:{
13:System.Console.WriteLine("{0}{1}{2}",x,y,z);
14:Console.ReadKey();
15:}
16:}
17:}
但是请不要循环依赖，否则编译器会检测报错：
1:usingSystem;
2:
3:namespaceAccessModifiers
4:{
5:publicclassProgram
6:{
7:privateconstintx=y+100;
8:privateconstinty=z-10;
9:privateconstintz=x;
10:
11:publicstaticvoidMain(string[]args)
12:{
13:System.Console.WriteLine("{0}{1}{2}",x,y,z);
14:Console.ReadKey();
15:}
16:}
17:}
检测报错：
本篇小结The evaluation of the constant value for 'AccessModifiers.Program.x' involves a circular definition
Class成员的默认修饰符为private
class 被标记为internal仅能被当前程序集访问.
Namespace默认为public修饰符，且不能添加修饰符。
class可以使用public 或 internal修饰符.不能使用修饰符 protected 、 private. class默认的修饰符为internal.
类成员可使用所有修饰符，默认为 private.
Protected internal修饰符约定了仅在继承类内有效.
在public 与 internal修饰符之间，public通常有更大的访问权限.
基类必须必子类有更大的修饰符访问权限，才可被子类继承.
函数返回值的修饰符要有能访问返回值的权限.
sealed Class无法被子类继承.
const变量，需要在声明时完成初始化，在编码阶段不能初始化.
类的const变量，可以彼此引用，但是不能形成循环引用.
const变量在编译器进行初始化，故const的运算可被执行.
const变量不能被标记为static.
Static 变量在类首次被加载时候初始化. int类型默认初始化为0，bool被初始化为False.
static readonly 字段无法被赋值，static构造函数或者变量初始化时刻除外.
参考原文：Diving into OOP (Day 5): All About C# Access Modifiers (Public/Private/Protected/Internal/Sealed/Constants/Static and Readonly Fields)
文章目录：
深入浅出OOP（一）: 多态和继承(早期绑定/编译时多态)
深入浅出OOP（二）: 多态和继承(继承)
深入浅出OOP（三）: 多态和继承(动态绑定/运行时多态)
深入浅出OOP（四）: 多态和继承(抽象类)
声明：本站所有文章资源内容，如无特殊说明或标注，均为采集网络资源。如若本站内容侵犯了原著者的合法权益，可联系本站删除。
