C# 编程语言中访问修饰符（access modifiers）

在 C# 编程语言中，有多个访问修饰符（access modifiers），其中包括 protected。这些修饰符用于控制类、成员和属性的访问级别和可见性。

protected 访问修饰符表示一个成员（字段、属性、方法）或类只能在其定义的类内部和该类的派生类中进行访问。也就是说，protected 成员可以在定义它们的类内部直接访问，以及在继承该类的派生类中进行访问。

下面是一些对 protected 访问修饰符的详细解释和示例说明：

protected 访问修饰符：

1. protected 成员的特点：

   • protected 成员可以在定义它们的类内部直接访问。
   • protected 成员可以在继承该类的派生类中进行访问。
   • protected 成员对于类外部的代码是不可见的。

2. protected 成员的使用场景：

   • 当一个类的某个成员需要在该类的派生类中使用，但对于其他类来说应该是不可见的时，可以将该成员声明为 protected。
   • protected 成员通常用于实现类的继承和多态性。

下面是一个示例代码，演示了 protected 成员的使用：

public class Animal
{
    protected string name; // 声明一个 protected 字段

    protected void PrintName() // 声明一个 protected 方法
    {
        Console.WriteLine("Animal Name: " + name);
    }
}

public class Dog : Animal
{
    public Dog(string dogName)
    {
        name = dogName; // 在派生类中访问基类的 protected 字段
    }

    public void DisplayName()
    {
        PrintName(); // 在派生类中调用基类的 protected 方法
    }
}

public class Program
{
    public static void Main()
    {
        Dog dog = new Dog("Buddy");
        dog.DisplayName(); // 输出：Animal Name: Buddy
    }
}

在上面的示例中，Animal 类定义了一个 protected 字段 name 和一个 protected 方法 PrintName()。派生类 Dog 继承了 Animal 类，并在其构造函数中访问了基类的 protected 字段。派生类还通过调用基类的 protected 方法 PrintName() 来输出动物的名称。

需要注意的是，如果尝试在 Main 方法中直接访问 Animal 类的 name 字段，会导致编译错误，因为 protected 成员对于类外部的代码是不可见的。只有在派生类内部才能访问 protected 成员。

除了 protected 访问修饰符外，C# 还提供了其他几个常用的访问修饰符，它们分别是：

1. public 访问修饰符：

• public 成员可以在任何地方进行访问，包括类内部、派生类和其他类。
• public 成员对于所有代码都是可见的。

下面是一个示例代码，演示了 public 访问修饰符的使用：

public class Person
{
    public string Name; // 声明一个 public 字段

    public void SayHello() // 声明一个 public 方法
    {
        Console.WriteLine("Hello, my name is " + Name);
    }
}

public class Program
{
    public static void Main()
    {
        Person person = new Person();
        person.Name = "John"; // 在类外部访问 public 字段
        person.SayHello(); // 在类外部调用 public 方法，输出：Hello, my name is John
    }
}

在上面的示例中，Person 类定义了一个 public 字段 Name 和一个 public 方法 SayHello()。这意味着这些成员可以在类内部和类外部的任何地方进行访问。

2. private 访问修饰符：

• private 成员只能在其定义的类内部进行访问。
• private 成员对于类外部的代码是不可见的。

下面是一个示例代码，演示了 private 访问修饰符的使用：

public class Car
{
    private string model; // 声明一个 private 字段

    private void StartEngine() // 声明一个 private 方法
    {
        Console.WriteLine("Engine started");
    }

    public void Drive()
    {
        StartEngine(); // 在类内部调用 private 方法
        Console.WriteLine("Driving the car");
    }
}

public class Program
{
    public static void Main()
    {
        Car car = new Car();
        car.Drive(); // 在类外部调用 public 方法，输出：Engine started\nDriving the car
        // car.StartEngine(); // 错误：无法访问 private 方法
        // car.model = "BMW"; // 错误：无法访问 private 字段
    }
}

在上面的示例中，Car 类定义了一个 private 字段 model 和一个 private 方法 StartEngine()。这意味着这些成员只能在 Car 类的内部进行访问，对于类外部的代码是不可见的。然而，Car 类还定义了一个 public 方法 Drive()，该方法在类内部调用了 private 方法 StartEngine()，并且可以在类外部进行访问。

3. internal 访问修饰符：

• internal 成员可以在同一程序集（assembly）内的任何类中进行访问。
• internal 成员对于不在同一程序集内的代码是不可见的。

下面是一个示例代码，演示了 internal 访问修饰符的使用：

// Assembly1.dll
public class MyClass
{
    internal int MyField; // 声明一个 internal 字段
    internal void MyMethod() // 声明一个 internal 方法
    {
        Console.WriteLine("Internal method");
    }
}

// Assembly2.dll
public class Program
{
    public static void Main()
    {
        MyClass myObj = new MyClass();
        myObj.MyField = 10; // 在同一程序集内访问 internal 字段
        myObj.MyMethod(); // 在同一程序集内调用 internal 方法
        // Console.WriteLine(myObj.MyField); // 错误：无法访问 internal 字段
        // myObj.MyMethod(); // 错误：无法调用 internal 方法
    }
}

在上面的示例中，MyClass 类定义了一个 internal 字段 MyField 和一个 internal 方法 MyMethod()。这些成员可以在同一程序集内的任何类中进行访问，但对于不在同一程序集内的代码是不可见的。

4. protected internal 访问修饰符：

• protected internal 成员可以在同一程序集内的任何类中进行访问，以及在派生类中进行访问，无论是否在同一程序集内。
• protected internal 成员对于不在同一程序集内且不是派生类的代码是不可见的。

下面是一个示例代码，演示了 protected internal 访问修饰符的使用：

// Assembly1.dll
public class MyBaseClass
{
    protected internal int MyField; // 声明一个 protected internal 字段
    protected internal void MyMethod() // 声明一个 protected internal 方法
    {
        Console.WriteLine("Protected Internal method");
    }
}

// Assembly2.dll
public class MyDerivedClass : MyBaseClass
{
    public void AccessBaseMembers()
    {
        MyField = 10; // 在派生类中访问 protected internal 字段
        MyMethod(); // 在派生类中调用 protected internal 方法
    }
}

public class Program
{
    public static void Main()
    {
        MyBaseClass myObj = new MyBaseClass();
        // myObj.MyField = 10; // 错误：无法访问 protected internal 字段
        // myObj.MyMethod(); // 错误：无法调用 protected internal 方法

        MyDerivedClass derivedObj = new MyDerivedClass();
        derivedObj.AccessBaseMembers(); // 在派生类外部访问 protected internal 成员
    }
}

在上面的示例中，MyBaseClass 类定义了一个 protected internal 字段 MyField 和一个 protected internal 方法 MyMethod()。这些成员可以在同一程序集内的任何类中进行访问，以及在派生类中进行访问，无论是否在同一程序集内。然而，对于不在同一程序集内且不是派生类的代码是不可见的。

这些访问修饰符可以帮助我们控制类成员的可见性和访问级别，以满足设计需求并提供适当的封装和封装性。