C# Access Modifiers
Published: 2023-10-05 11:17:45

Well, since we started talking about classes in C#, we can't escape **access modifiers**.

### What is **access modifiers**?

In C#, **access modifiers** specify the accessibility of types (classes, interfaces, etc) and type members (fields, methods, etc). For example:

```cs
class Student
{
   private int age = 12;
   public string name = "Bob";
}
```
age - private field can only be accessed within the `Student` class
name - public field that can be accessed from anywhere.

### 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:

```cs
using System;

namespace AccessModifiers 
{
  class Student 
  {
    public string name = "Bob";
      
    public void SayHello() =>
      Console.WriteLine("Hello from Student class");
  }

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

      // accessing SayHello method from Student
      student.SayHello();
     }
  }
}
```
**Output**

```cs
Name: Bob
Hello from Student class
```
In the above example, we have created a class named `Student` with a field `name` and a method `SayHello()`.

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

      // accessing SayHello method from Student
      student.SayHello();
```
Since the field and method are public, we are able to access them from the `Program` class.

**Note:** We have used the object `student` 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:

```cs
using System;

namespace AccessModifiers 
{
  class Student 
  {
    private string name = "Bob";
      
    private void SayHello() =>
      Console.WriteLine("Hello from Student class");
  }

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

      // accessing SayHello method from Student
      student.SayHello();
    }
  }
}
```
In the above example, we have created a class named `Student` with a field `name` and a method `SayHello()`.

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

      // accessing SayHello method from Student
      student.SayHello();
```
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.

```cs
Error    CS0122    'Student.name' is inaccessible due to its protection level    
Error    CS0122    'Student.SayHello()' 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:

```cs
using System;

namespace AccessModifiers 
{
  class Student 
  {
    protected string name = "Bob";
  }

  class Program 
  {
    static void Main(string[] args) 
    {
      // creating object of student class
      Student student = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);
    }
  }
}
```
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:

```cs
Error    CS0122    'Student.name' is inaccessible due to its protection level
```
Now, let's try to access the protected member from a derived class:

```cs
using System;

namespace AccessModifiers 
{
  class Student 
  {
    protected string name = "Bob";
  }
  
  // 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);
    }
  }
}
```
**Output**

```cs
Name: Bob
```
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.

```cs
// 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, that is, we cannot call `internal` from another project in our `Solutions`.

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.

Call in our project. For example:

```cs
using System;

namespace AccessModifiers 
{
  class Student 
  {
   internal string name = "Bob";
  }

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

```
Name: Bob
```
Call in another project. For example:

```cs
using System;

namespace SecondAccessModifiers 
{
  class Program 
  {
    static void Main(string[] args) 
    {
      // creating object of Student class
      Student student = new Student();
      
      // accessing name field and printing it
      Console.WriteLine("Name: " + student.name);
    }
  }
}
```
**Note:** Pay attention to the `namespace`, it is different from the first project.
**Output**

```cs
Error    CS0122    'student.name' is inaccessible due to its protection level
```
### Conclusion

In general, **access modifiers** allow you to specify the allowed scope for class components. That is, access modifiers determine the context in which a given variable or method can be used.

I have a lot of interesting code on **[GitHub](https://github.com/ZafarUrakov)**