C# Access Modifiers

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:

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:

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

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().

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

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().

      // 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.

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:

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:

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

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.

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

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:

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

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