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的私有成员
}
}