C# 访问修饰符

在本教程中，我们将通过示例了解 C# 中的 public、private、protected 和 internal 访问修饰符。

在 C# 中，访问修饰符指定类型（类、接口等）和类型成员（字段、方法等）的可访问性。例如，

class Student {

  public string name;
    
  private int num;

  }

在这里，

名称 - 可以从任何地方访问的公共字段
数量 - 私有字段只能在 Student 内部访问类

访问修饰符的类型

在 C# 中，有 4 种基本类型的访问修饰符。

公开
私人的
受保护
内部

1.公共访问修饰符

当我们声明一个类型或类型成员 public ，它可以从任何地方访问。例如，

using System;

namespace MyApplication {

  class Student {
    public string name = "Sheeran";
      
    public void print() {
      Console.WriteLine("Hello from Student class");
     }
  }

  class Program {
    static void Main(string[] args) {
    
      // creating object of Student class
      Student student1 = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + student1.name);

      // accessing print method from Student
      student1.print();
      Console.ReadLine();
    }
  }
}

输出

Name: Sheeran
Hello from Student class

在上面的例子中，我们创建了一个名为 Student 的类带有字段 name 和一个方法 print() .

// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);

// accessing print method from Student
student1.print();

由于字段和方法是公开的，我们可以从 Program 访问它们类。

注意 :我们使用了对象 student1 学生 类来访问其成员。要了解更多信息，请访问 C# 类和对象 .

2。私有访问修饰符

当我们用 private 声明一个类型成员时访问修饰符，只能在同一个class内访问或 struct .例如，

using System;

namespace MyApplication {

  class Student {
    private string name = "Sheeran";
      
    private void print() {
      Console.WriteLine("Hello from Student class");
     }
  }

  class Program {
    static void Main(string[] args) {
    
      // creating object of Student class
      Student student1 = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + student1.name);

      // accessing print method from Student
      student1.print();

      Console.ReadLine();
    }
  }
}

在上面的例子中，我们创建了一个名为 Student 的类带有字段 name 和一个方法 print() .

// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);

// accessing print method from Student
student1.print();

由于字段和方法是私有的，我们无法从 Program 访问它们班级。在这里，代码会产生如下错误。

Error    CS0122    'Student.name' is inaccessible due to its protection level    
Error    CS0122    'Student.print()' is inaccessible due to its protection level

3。受保护的访问修饰符

当我们将类型成员声明为 protected ，它只能从同一个类及其派生类访问。例如，

using System;

namespace MyApplication {

  class Student {
    protected string name = "Sheeran";
  }

  class Program {
    static void Main(string[] args) {
    
      // creating object of student class
      Student student1 = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + student1.name);
      Console.ReadLine();
    }
  }
}

在上面的例子中，我们创建了一个名为 Student 的类带有字段 name .由于该字段受到保护，我们无法从 Program 访问它类。

在这里，代码会产生如下错误。

Error    CS0122    'Student.name' is inaccessible due to its protection level

现在，让我们尝试访问 protected 派生类的成员。

using System;

namespace MyApplication {

  class Student {
    protected string name = "Sheeran";
  }
  
  // derived class
  class Program : Student {
    static void Main(string[] args) {

      // creating object of derived class
      Program program = new Program();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + program.name);
      Console.ReadLine();
    }
  }
}

输出

Name: Sheeran

在上面的例子中，我们创建了一个类 Student 带有受保护的字段 name .请注意，我们继承了 Program 学生的班级类。

// accessing name field and printing it
Console.WriteLine("Name: " + program.name);

自protected 成员可以从派生类中访问，我们可以访问 name 来自程序 类。

4。内部访问修饰符

当我们将类型或类型成员声明为 internal ，只能在同一个程序集中访问。

程序集是类型（类、接口等）和资源（数据）的集合。它们被构建为一起工作并形成功能的逻辑单元。

这就是为什么当我们运行一个程序集时，程序集中的所有类和接口都一起运行。要了解更多信息，请访问 C# 程序集。

示例：同一程序集中的内部

using System;

namespace Assembly {

  class Student {
   internal string name = "Sheeran";
  }

  class Program {
    static void Main(string[] args) {
    
      // creating object of Student class
      Student theStudent = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + theStudent.name);
      Console.ReadLine();
    }
  }
}

输出

Name: Sheeran

在上面的例子中，我们创建了一个名为 Student 的类带有字段 name .由于该字段是 internal ，我们可以从 Program 访问它类，因为它们在同一个程序集中。

如果我们使用 internal 在单个程序集中，它就像 public 访问修饰符。

示例：不同程序集中的内部

让我们先创建一个程序集。

// Code on Assembly1
using System;

namespace Assembly1 {

  public class StudentName {
    internal string name = "Sheeran";
  }

  class Program {
    static void Main(string[] args) {
    }
  }
}

此处，此代码在 Assembly1 中 .我们创建了一个内部字段 name 在类 StudentName 内 .现在，该字段只能从同一个程序集 Assembly1 访问 .

现在，让我们创建另一个程序集。

// Code on Assembly2
using System;

// access Assembly1
using Assembly1;

namespace Assembly2 {
  class Program {
    static void Main(string[] args) {
      StudentName student = new StudentName();

      // accessing name field from Assembly1
      Console.Write(student.name);
      Console.ReadLine();
     }
  }
}

此处，此代码在 Assembly2 中 .我们正在尝试访问 name StudentName 的字段类（Assembly1 )。

从 Assembly1 访问字段，我们首先需要设置Assembly1的引用在Assembly2中 .现在是代码

using Assembly1;

允许我们使用 Assembly1 中的代码到 Assembly2 .

在这里，当我们尝试访问 name Assembly2 中的字段，我们得到一个错误。

Error    CS0122    'StudentName.name' is inaccessible due to its protection level

这是因为 name 是 Assembly1 中存在的内部字段 .

5.受保护的内部访问修饰符

protected internal 是 protected 的组合和 internal 访问修饰符。

当我们声明一个成员 protected internal ，它可以从同一个程序集和任何其他程序集的包含类的派生类访问。

// Code on Assembly1
using System;

namespace Assembly1 {
  public class Greet {
    protected internal string msg="Hello";
  }

  class Program {
    static void Main(string[] args) {
      Greet greet = new Greet();
      Console.WriteLine(greet.msg);
      Console.ReadLine();
     }
  }
}

输出

Hello

上面的代码在 Assembly1 .

在上面的例子中，我们创建了一个名为 Greet 的类带有字段 msg .由于该字段受内部保护，我们可以从 Program 访问它类，因为它们在同一个程序集中。

让我们从 Greet 派生一个类在另一个程序集中并尝试访问受保护的内部字段 msg 来自它。

// Code on Assembly2
using System;

// access Assembly1
using Assembly1;

namespace Assembly2 {

  // derived class of Greet
  class Program: Greet {
    static void Main(string[] args) {
      Program greet = new Program();

      // accessing name field from Assembly1
      Console.Write(greet.msg);
      Console.ReadLine();
    }
  }
}

输出

Hello

上面的代码在 Assembly2 .

在上面的例子中，我们继承了 Program Greet 中的类类（来自 Assembly1 )。

// accessing name field from Assembly1
Console.Write(greet.msg);

我们可以访问 msg 来自 问候 Assembly1 的类来自 Assembly2 .

这是因为 msg 是一个受保护的内部字段，我们正在尝试从 Greet 的子类访问它 .

6。私有保护访问修饰符

private protected 访问修饰符是 private 的组合和 protected .它可从 C# 版本 7.2 及更高版本获得。

当我们声明一个成员 private protected ，它只能在同一个类中访问，并且它的派生类在同一个程序集中。例如，

// Code in Assembly1
using System;

namespace Assembly1 {
  public class StudentName {
    private protected string name = "Sheeran";
  }

  //derived class of StudentName class
  class Program1 : StudentName {

    static void Main(string[] args) {

      Program1 student = new Program1();

      //  accessing name field from base class
      Console.Write(student.name);
      Console.ReadLine();
    }
  }
}

输出

Sheeran

上面的代码在 Assembly1

在上面的例子中，我们创建了一个类 StudentName 带有 private protected 字段 名称 .

请注意，我们继承了 Program1 StudentName 的班级类。

自private protected 成员可以从同一个程序集中的派生类访问，我们可以访问 name 来自 Program1 类。

让我们从 StudentName 派生一个类在另一个程序集中并尝试访问私有受保护字段 name 从中。例如，

// Code in Assembly2
using System;
//access Assembly1
using Assembly1;

namespace Assembly2 {

  //derived class of StudentName
  class Program : StudentName {
    static void Main(string[] args) {
      Program student = new Program();
    
      // accessing name field from Assembly1
      Console.Write(student.name);
      Console.ReadLine();
     }
  }
}

上面的代码在 Assembly2

在上面的例子中，当我们尝试访问 name StudentName 派生类的字段，我们得到一个错误。

Error    CS0122    'StudentName.name' is inaccessible due to its protection level

这是因为 name 字段在 Assembly1 中并且派生类在 Assembly2 .

注意：我们也可以对类型（类、接口等）使用访问修饰符。但是，我们只能使用带有公共和内部访问修饰符的类型。

C# 方法 C# 变量范围

C语言