访问修饰符是定义程序中成员，类或数据类型的可访问性的关键字。这些主要用于限制外部程序或类对不需要的数据进行操作。有4种访问修饰符(公共，受保护，内部，私有)，它们定义了6种可访问性级别，如下所示：
- 上市
- 受保护的
- 内部的
- 受保护的内部
- 私人的
- 私人保护
这些修饰符的辅助功能表如下：
| public | protected | internal | protected internal | private | private protected | |
|---|---|---|---|---|---|---|
| Entire program | Yes | No | No | No | No | No |
| Containing class | Yes | Yes | Yes | Yes | Yes | Yes |
| Current assembly | Yes | No | Yes | Yes | No | No |
| Derived types | Yes | Yes | No | Yes | No | No |
| Derived types within current assembly | Yes | Yes | Yes | Yes | No | Yes |
公众访问级别
授予对整个程序的访问权限。这意味着包含类引用的另一个方法或另一个程序集可以访问这些成员或类型。与所有其他访问修饰符相比，此访问修饰符具有最高的访问级别。
句法：
public TypeName示例：在这里，我们声明一个Student类，它由两个公开的类成员rollNo和name组成。这些成员可以从当前代码中的所有代码以及程序中的另一个程序集的任何位置访问。方法getRollNo和getName也声明为public。
// C# Program to show the use of
// public Access Modifier
using System;
namespace publicAccessModifier {
class Student {
// Declaring members rollNo
// and name as public
public int rollNo;
public string name;
// Constructor
public Student(int r, string n)
{
rollNo = r;
name = n;
}
// methods getRollNo and getName
// also declared as public
public int getRollNo()
{
return rollNo;
}
public string getName()
{
return name;
}
}
class Program {
// Main Method
static void Main(string[] args)
{
// Creating object of the class Student
Student S = new Student(1, "Astrid");
// Displaying details directly
// using the class members
// accessible through another method
Console.WriteLine("Roll number: {0}", S.rollNo);
Console.WriteLine("Name: {0}", S.name);
Console.WriteLine();
// Displaying details using
// member method also public
Console.WriteLine("Roll number: {0}", S.getRollNo());
Console.WriteLine("Name: {0}", S.getName());
}
}
}
输出：
Roll number: 1
Name: Astrid
Roll number: 1
Name: Astrid
受保护的可访问性级别
访问仅限于包含此类的成员和派生类型的类。这意味着一个类，它是程序中任何地方都可以访问受保护成员的包含类的子类。
句法：
protected TypeName示例：在下面给出的代码中，类Y从X继承，因此，可以从Y访问X的任何受保护成员，但不能修改值。
// C# Program to show the use of
// protected Access Modifier
using System;
namespace protectedAccessModifier {
class X {
// Member x declared
// as protected
protected int x;
public X()
{
x = 10;
}
}
// class Y inherits the
// class X
class Y : X {
// Members of Y can access 'x'
public int getX()
{
return x;
}
}
class Program {
static void Main(string[] args)
{
X obj1 = new X();
Y obj2 = new Y();
// Displaying the value of x
Console.WriteLine("Value of x is : {0}", obj2.getX());
}
}
}
输出：
Value of x is : 10
内部可达性级别
访问仅限于当前程序集，也就是说，在同一名称空间内的任何位置都可以访问声明为internal的任何类或类型。它是C＃中的默认访问修饰符。
句法：
internal TypeName示例：在下面给出的代码中，类Complex是internalAccessModifier命名空间的一部分，可在整个命名空间中访问。
// C# Program to show use of
// internal access modifier
// Inside the file Program.cs
using System;
namespace internalAccessModifier {
// Declare class Complex as internal
internal class Complex {
int real;
int img;
public void setData(int r, int i)
{
real = r;
img = i;
}
public void displayData()
{
Console.WriteLine("Real = {0}", real);
Console.WriteLine("Imaginary = {0}", img);
}
}
// Driver Class
class Program {
// Main Method
static void Main(string[] args)
{
// Instantiate the class Complex
// in separate class but within
// the same assembly
Complex c = new Complex();
// Accessible in class Program
c.setData(2, 1);
c.displayData();
}
}
}
输出：
Real = 2
Imaginary = 1
注意：如果您在同一代码中添加另一个文件，则在该名称空间中将无法访问类Complex ，并且编译器会给出错误。
// C# program inside file xyz.cs
// separate nampespace named xyz
using System;
namespace xyz {
class text {
// Will give an error during compilation
Complex c1 = new Complex();
c1.setData(2, 3);
}
}
输出：
error CS1519
受保护的内部可访问性级别
访问仅限于当前程序集或包含类的派生类型。这意味着将授予对从当前Assembly内部或外部包含的类派生的任何类的访问权限。
句法：
protected internal TypeName示例：在下面给出的代码中，成员’ value ‘被声明为内部受保护的，因此可以在整个Parent类中访问，也可以在同一程序集中的任何其他类(如ABC)中访问它。也可以在派生自Parent的另一个类(即Child)中访问另一个程序集。
// Inside file parent.cs
using System;
public class Parent {
// Declaring member as protected internal
protected internal int value;
}
class ABC {
// Trying to access
// value in another class
public void testAccess()
{
// Member value is Accessible
Parent obj1 = new Parent();
obj1.value = 12;
}
}
// Inside file GFg.cs
using System;
namespace GFG {
class Child : Parent {
// Main Method
public static void Main(String[] args)
{
// Accessing value in another assembly
Child obj3 = new Child();
// Member value is Accessible
obj3.value = 9;
Console.WriteLine("Value = " + obj3.value);
}
}
}
输出：
Value = 9
私人可及等级
访问仅授予包含的类。当前或另一个程序集中的任何其他类均未被授予访问这些成员的权限。
句法：
private TypeName示例：在此代码中，我们将Parent类的成员值声明为private，因此其访问仅限于包含类。我们尝试访问名为Child的派生类内部的值，但编译器引发错误{错误CS0122：“ PrivateAccessModifier.Parent.value”由于其保护级别而无法访问}。同样，在main {这是另一个类中的方法}内部。 obj.value将引发以上错误。因此，我们可以使用可以设置或获取私有成员值的公共成员方法。
// C# Program to show use of
// the private access modifier
using System;
namespace PrivateAccessModifier {
class Parent {
// Member is declared as private
private int value;
// value is Accessible
// only inside the class
public void setValue(int v)
{
value = v;
}
public int getValue()
{
return value;
}
}
class Child : Parent {
public void showValue()
{
// Trying to access value
// Inside a derived class
// Console.WriteLine( "Value = " + value );
// Gives an error
}
}
// Driver Class
class Program {
static void Main(string[] args)
{
Parent obj = new Parent();
// obj.value = 5;
// Also gives an error
// Use public functions to assign
// and use value of the member 'value'
obj.setValue(4);
Console.WriteLine("Value = " + obj.getValue());
}
}
}
输出：
Value = 4
私有受保护的可访问性级别
授予对当前程序集中存在的包含类及其派生类型的访问权限。此修饰符在C＃7.2版和更高版本中有效。
句法：
private protected TypeName示例：此代码与上面的代码相同，但是由于成员值的访问修饰符为“私有保护”，因此现在可以在派生类或父级(即子级)内部访问。可能存在于另一个程序集中的任何派生类将无法访问这些受保护的私有成员。
// C# Program to show use of
// the private protected
// Accessibility Level
using System;
namespace PrivateProtectedAccessModifier {
class Parent {
// Member is declared as private protected
private protected int value;
// value is Accessible only inside the class
public void setValue(int v)
{
value = v;
}
public int getValue()
{
return value;
}
}
class Child : Parent {
public void showValue()
{
// Trying to access value
// Inside a derived class
Console.WriteLine("Value = " + value);
// value is accesible
}
}
// Driver Code
class Program {
// Main Method
static void Main(string[] args)
{
Parent obj = new Parent();
// obj.value = 5;
// Also gives an error
// Use public functions to assign
// and use value of the member 'value'
obj.setValue(4);
Console.WriteLine("Value = " + obj.getValue());
}
}
}
输出：
Value = 4
重要事项：
- 命名空间不允许使用访问修饰符，因为它们没有访问限制。
- 一次只能允许用户使用一种可访问性，但受私有保护和受保护的Internal除外。
- 顶级类型(不嵌套在其他类型中，只能具有公共或内部可访问性)的默认可访问性是内部的。
- 如果没有为成员声明指定访问修饰符，则根据上下文使用默认的可访问性。