C# Access Modifiers

In this tutorial, we will learn about the public, private, protected, and internal access modifiers in C#
with the help of examples.
In C#, access modifiers specify the accessibility of types (classes, interfaces, etc) and type members
(fields, methods, etc). For example,
class Student {

public string name;

private int num;

}
Here,
 name - public field that can be accessed from anywhere
 num - private field can only be accessed within the Student class
Types of Access Modifiers
In C#, there are 4 basic types of access modifiers.
 public
 private
 protected
 internal

1. public access modifier

When we declare a type or type member public, it can be accessed from anywhere. For example,
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();
}
}
}
Output
Name: Sheeran
Hello from Student class
In the above example, we have created a class named Student with a field name and a
method print().
// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);

// accessing print method from Student

student1.print();
Since the field and method are public, we are able to access them from the Program class.
Note: We have used the object student1 of the Student class to access its members. To learn
more, visit the C# class and objects.

2. private access modifier

When we declare a type member with the private access modifier, it can only be accessed within
the same class or struct. For example,
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();
}
}
}
In the above example, we have created a class named Student with a field name and a
method print().
// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);

// accessing print method from Student

student1.print();
Since the field and method are private, we are not able to access them from the Program class. Here,
the code will generate the following error.
Error CS0122 'Student.name' is inaccessible due to its protection level
Error CS0122 'Student.print()' is inaccessible due to its protection level

3. protected access modifier

When we declare a type member as protected, it can only be accessed from the same class and its
derived classes. For example,
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();
}
}
}
In the above example, we have created a class named Student with a field name. Since the field is
protected, we are not able to access it from the Program class.
Here, the code will generate the following error.
Error CS0122 'Student.name' is inaccessible due to its protection level
Now, let's try to access the protected member from a derived class.
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();
}
}
}
Output
Name: Sheeran
In the above example, we have created a class Student with a protected field name. Notice that we
have inherited the Program class from the Student class.
// accessing name field and printing it
Console.WriteLine("Name: " + program.name);
Since the protected member can be accessed from derived classes, we are able to
access name from the Program class.

4. internal access modifier

When we declare a type or type member as internal, it can be accessed only within the same
assembly.
An assembly is a collection of types (classes, interfaces, etc) and resources (data). They are built to
work together and form a logical unit of functionality.
That's why when we run an assembly all classes and interfaces inside the assembly run together. To
learn more, visit the C# Assembly.

Example: internal within the same Assembly

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();
}
}
}
Output
Name: Sheeran
In the above example, we have created a class named Student with a field name. Since the field
is internal, we are able to access it from the Program class as they are in the same assembly.
If we use internal within a single assembly, it works just like the public access modifier.

Example: internal in different Assembly

Let's create one assembly first.
// Code on Assembly1
using System;

namespace Assembly1 {

public class StudentName {

internal string name = "Sheeran";
}

class Program {
static void Main(string[] args) {
}
}
}
Here, this code is in Assembly1. We have created an internal field name inside the
class StudentName. Now, this field can only be accessed from the same assembly Assembly1.
Now, let's create another assembly.
// 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();
}
}
}
Here, this code is in Assembly2. We are trying to access the name field of
the StudentName class(Assembly1).
To access fields from Assembly1, we first need to set the reference of Assembly1 in Assembly2.
Now the code
using Assembly1;
allows us to use the code from Assembly1 to Assembly2.
Here, when we try to access the name field from Assembly2, we get an error.
Error CS0122 'StudentName.name' is inaccessible due to its protection level
This is because name is an internal field present in Assembly1.

5. protected internal access modifier

The protected internal is a combination of protected and internal access modifiers.
When we declare a member protected internal, it can be accessed from the same assembly and
the derived class of the containing class from any other assembly.
// 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();
 }
}
}
Output
Hello
The above code is in Assembly1.
In the above example, we have created a class named Greet with a field msg. Since the field is
protected internal, we are able to access it from the Program class as they are in the same assembly.
Let's derive a class from Greet in another assembly and try to access the protected internal
field msg from it.
// 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();
}
}
}
Output
Hello
The above code is in Assembly2.
In the above example, we have inherited the Program class from the Greet class(from Assembly1).
// accessing name field from Assembly1
Console.Write(greet.msg);
We are able to access the msg from the Greet class of Assembly1 from Assembly2.
This is because the msg is a protected internal field and we are trying to access it from the child class
of Greet.

6. private protected access modifier

The private protected access modifier is a combination of private and protected. It is available
from the C# version 7.2 and later.
When we declare a member private protected, it can only be accessed within the same class,
and its derived class within the same assembly. For example,
// 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();
}
}
}
Output
Sheeran
The above code is in Assembly1
In the above example, we have created a class StudentName with a private protected field name.
Notice that we have inherited the Program1 class from the StudentName class.
Since the private protected member can be accessed from derived classes within the same
assembly, we are able to access name from the Program1 class.
Let's derive a class from StudentName in another assembly and try to access the private protected
field name from it. For example,
// 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();
 }
}
}
The above code is in Assembly2
In the above example, when we try to access the name field from the derived class of StudentName,
we get an error.
Error CS0122 'StudentName.name' is inaccessible due to its protection level
This is because the name field is in Assembly1 and the derived class is in Assembly2.