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()。这些成员可以在同一程序集内的任何类中进行访问，以及在派生类中进行访问，无论是否在同一程序集内。然而，对于不在同一程序集内且不是派生类的代码是不可见的。

---

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