C#阶段提高之访问修饰符

      修饰符用于修改类型和类型成员的声明。C#的访问修饰符就那么几种，但是深究起来是很有讲究的，有时间凭空想象会造成使用的错误。下来我来说说访问修饰符的使用。访问修饰符分为类型访问修饰符，类成员访问修饰符。其中类型修饰符一共两种：Internal，public。而成员的访问修饰符有public，private，protected，internal四种。

public 关键字是类型和类型成员的访问修饰符。 公共访问是允许的最高访问级别。对访问公共成员没有限制，如下例所示：

class Class1
{
    public int x; // 没有访问限制
}

两个类中的互相访问没有限制：

class PointTest
{
    public int x;
    public int y;
}

class Class1
{
    static void Main()
    {
        PointTest p = new PointTest();
        p.x = 10;
        p.y = 15;
        Console.WriteLine("x = {0}, y = {1}", p.x, p.y);
    }
}
// Output: x = 10, y = 15

private修饰符就会出现限制了，请看：

class Employee2
{
    private string name = "FirstName, LastName";
    private double salary = 100.0;

    public string GetName()
    {
        return name;
    }

    public double Salary
    {
        get { return salary; }
    }
}

class PrivateTest
{
    static void Main()
    {
        Employee2 e = new Employee2();

        // The data members are inaccessible (private), so
        // they can't be accessed like this:
        //    string n = e.name;
        //    double s = e.salary;

        // 'name' is indirectly accessed via method:
        string n = e.GetName();

        // 'salary' is indirectly accessed via property
        double s = e.Salary;
    }
}

internal 关键字是类型和类型成员的访问修饰符。 只有在同一程序集的文件中，内部类型或成员才是可访问的，如下例所示：

public class BaseClass
{
    // Only accessible within the same assembly
    internal static int x = 0;
}

声明的是internal，在内部的成员或内部程序集中是可以访问的，出了程序集就没有访问的权限了。从当前程序集或从包含类派生的类型，可以访问具有访问修饰符 protected internal 的类型或成员。

此示例包含两个文件： Assembly1.cs 和 Assembly1_ a.cs。 第一个文件包含内部基类 BaseClass。 在第二个文件中，实例化 BaseClass 的尝试将产生错误。

// Assembly1.cs
// Compile with: /target:library
internal class BaseClass
{
   public static int intM = 0;
}
// Assembly1_a.cs
// Compile with: /reference:Assembly1.dll--引用程序集Assembly1.dll
class TestAccess
{
   static void Main()
   {
     //下面的实例化将产生错误
      BaseClass myBase = new BaseClass();
   }
}
提示错误可以看见：访问保护受到限制！

原因十分明确，第一个类声明的是internal类型，第二个类引用第一个程序集Assembly1.dll,但是已经出了这个程序集，因此无效的实例化。

protected 关键字是一个成员访问修饰符。 受保护成员在其所在的类中可由派生类实例访问。例子：

class A
{
    protected int x = 123;
}

class B : A
{
    static void Main()
    {
        A a = new A();
        B b = new B();

        // classes derived from A.
        // a.x = 10;

        // OK, because this class derives from A.
        b.x = 10;
    }
}

语句 a.x = 10 生成错误，因为它是在静态方法 Main 中生成的，而不是类 B 的实例。

结构成员无法受保护，因为无法继承结构。

一个成员或类型只能有一个访问修饰符，但使用 protected  internal 组合时除外。可以访问仅限于从包含类派生的当前程序集或类型。