C#设置访问权限
在C#中有一个规定：编译器不允许派生类的可访问性比其基类更高。也就是说，内部类可以继承于一个公共类，但公共类不能继承于一个内部类。
１、public 关键字是类型和类型成员的访问修饰符。公共访问是允许的最高访问级别。对于访问公共成员没有限制。
有关 public 与其他访问修饰符的比较，请参见可访问性级别。
示例
在下例中，声明了两个类：MyClass1 和 MyClass2。直接从 MyClass2 访问 MyClass1 的公共成员 x 和 y。
// protected_public.cs
// Public access
using System;
class MyClass1
{
public int x;
public int y;
}
class MyClass2
{
public static void Main()
{
MyClass1 mC = new MyClass1();
// Direct access to public members:
mC.x = 10;
mC.y = 15;
Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
}
}
输出
x = 10, y = 15
如果将 public 访问级别更改为 private 或 protected，将收到错误信息：
'MyClass1.y' is inaccessible due to its protection level.
２、protected 关键字是一个成员访问修饰符。从声明受保护的成员的类中，以及从声明受保护的成员的类派生的任何类中都可以访问该成员。
仅当访问通过派生类类型发生时，基类的受保护成员在派生类中才是可访问的。例如，请看以下代码段：
class A
{
protected int x = 123;
}
class B : A
{
void F()
{
A a = new A();
B b = new B();
a.x = 10; // Error
b.x = 10; // OK
}
}
语句 a.x =10 将生成错误，因为 A 不是从 B 派生的。
结构成员无法受保护，因为无法继承结构。
对于不是从受保护的成员的类派生的类，引用其中受保护的成员是错误的。
有关受保护的成员的更多信息，请参见 3.5.3 实例成员的受保护访问。
有关 protected 与其他访问修饰符的比较，请参见可访问性级别。
示例
在此示例中，类 MyDerivedC 从 MyClass 派生；因此，可以从该派生类直接访问基类的受保护成员。
// protected_keyword.cs
using System;
class MyClass
{
protected int x;
protected int y;
}
class MyDerivedC: MyClass
{
public static void Main()
{
MyDerivedC mC = new MyDerivedC();
// Direct access to protected members:
mC.x = 10;
mC.y = 15;
Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
}
}
输出
x = 10, y = 15
如果将 x 和 y 的访问级别更改为 private，编译器将发出错误信息：
'MyClass.y' is inaccessible due to its protection level.
'MyClass.x' is inaccessible due to its protection level.
３、private 关键字是一个访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结构体中才是可访问的。
同一体中的嵌套类型也可以访问那些私有成员。
在定义私有成员的类或结构外引用它会导致编译时错误。
有关 private 和其他访问修饰符的比较，请参见可访问性级别。
示例
在此例中，Employee 类包含一个公共成员 Name 和一个私有成员 Salary。可以直接访问公共成员，对于私有成员则必须通过公共方法 AccessSalary() 访问。
// private_keyword.cs
using System;
class Employee
{
public string name = "xx";
double salary = 100.00; // private access by default
public double AccessSalary() {
return salary;
}
}
class MainClass
{
public static void Main()
{
Employee e = new Employee();
// Accessing the public field:
string n = e.name;
// Accessing the private field:
double s = e.AccessSalary();
}
}
在上面的示例中，如果试图通过使用如下语句直接访问私有成员：
double s = e.salary;
将收到错误信息：
'Employee.Salary' is inaccessible due to its protection level.
注：以上资源来源于MSDN
另一个例子：
using System;
class TestFirst
{
public string s; //公有成员
protected int i; //保护成员
private double d; //私有成员
public void funFirst()
{
s="Welcome 同学们!";//正确，允许访问自身成员
i=100; //正确，允许访问自身成员
d=77.77; //正确，允许访问自身成员
}
public static void Main(string[] args)
{
TestFirst first=new TestFirst();
TestSecond second=new TestSecond();
TestThird third=new TestThird();
first.s="first 同学们，你好！";
Console.WriteLine("{0}",first.s);
second.funSecond();
third.funThird();
}
}
class TestSecond:TestFirst //在C#这叫派生
{
int x; //私有成员
public void funSecond()
{
x=100; //正确，允许访问自身成员
s="second 同学们!"; //正确，允许访问类TestFirst的公有成员
Console.WriteLine("{0}",s);
//d=222.22; //错误，不能访问类TestFirst的私有成员
i=222; //正确，允许访问类TestFirst的保护成员
}
}
class TestThird
{
public void funThird()
{
TestFirst c=new TestFirst(); //声明类TestFirst的实例c
c.s="third dongguo!"; //正确，允许访问类TestFirst的公有成员
Console.WriteLine("{0}",c.s);
//c.d=333.333; //错误，不能访问类TestFirst的保护成员
//c.i=333; //错误，不能访问类TestFirst的私有成员
}
}
