Access Modifiers In C# Complete Guide

1. Public (public)

• Definition: When a member is declared public, it is accessible from any other code in the same assembly or another assembly that references it.
• Usage: Used when you need to expose a class or its members to the entire application.
• Example:

  public class Employee {
      public string Name { get; set; }
      public void Display() {
          Console.WriteLine(Name);
      }
  }
  

• Important Info: While convenient, overusing public can lead to poorly designed and harder-to-maintain software. Use it judiciously.

2. Private (private)

• Definition: private members are only accessible within the class they are declared in.
• Usage: Common for encapsulating data and providing controlled access through methods or properties.
• Example:

  public class Employee {
      private string name;
      public void SetName(string n) {
          name = n;
      }
      public void Display() {
          Console.WriteLine(name);
      }
  }
  

• Important Info: Enhances security by preventing direct access from outside the class. It is good practice to keep fields private and expose them via public properties.

3. Protected (protected)

• Definition: A protected member can be accessed within its own class and by derived classes.
• Usage: Provides a way to limit access to derived classes while keeping the member hidden from outside.
• Example:

  public class Employee {
      protected string name;
      public void SetName(string n) {
          name = n;
      }
  }
  
  public class Manager : Employee {
      public void PrintDetails() {
          Console.WriteLine(name); // Can access the protected field
      }
  }
  

• Important Info: Useful in scenarios where you want derived classes to have access to certain members without exposing them globally.

4. Internal (internal)

• Definition: Members declared as internal are accessible throughout their containing assembly but not from other assemblies.
• Usage: Allows different files within a single project to communicate without being exposed to external users.
• Example:

  internal class InternalData {
      internal void PrintMessage() {
          Console.WriteLine("This is an internal message.");
      }
  }
  

• Important Info: This modifier is particularly useful when you are building a library and want to expose functionality within that library but not expose it to consumers of the library.

5. Protected Internal (protected internal)

• Definition: This is a combination of protected and internal. The member can be accessed within its containing assembly and by derived classes, even if the derived class is in a different assembly.
• Usage: Allows flexibility in sharing functionality between the same assembly and derived classes in another assembly.
• Example:

  public class Employee {
      protected internal string Department { get; set; }
  }
  
  namespace AnotherNamespace {
      public class Manager : Employee {
          public void ShowDepartment() {
              Console.WriteLine(Department); // Can access Department due to protected internal
          }
      }
  }
  

• Important Info: It’s typically used when you want to allow subclasses defined outside the main project to access certain fields or methods that aren’t meant for external use.

6. Private Protected (private protected)

• Definition: Available starting from C# 7.2, private protected limits access to members that can be called only within its containing class or by types derived from that class within the same assembly.
• Usage: Ensures that certain properties and fields are only accessible within the same assembly, adding another layer of data protection.
• Example:

  public class Employee {
      private protected string Salary;
  }
  
  namespace SameAssembly {
      public class Manager : Employee {
          public void ShowSalary() {
              Console.WriteLine(Salary); // Can access Salary within the same assembly
          }
      }
  }
  
  namespace AnotherAssembly {
      public class Manager : Employee {
          public void ShowSalary() {
              Console.WriteLine(Salary); // Compile-time error: Salary inaccessible
          }
      }
  }
  

• Important Info: Helps prevent misuse of inheritance by ensuring that only members within the same assembly can utilize the protected member.

Key Concepts and Best Practices

• Encapsulation: The primary goal of using access modifiers is to ensure encapsulation. By restricting access, you can protect the integrity of your data and operations.

• Choosing the Right Modifier:

  • Start with the most restrictive access level and make it more accessible only if required.
  • Use public sparingly; prefer internal, protected, or private.

• Combining Modifiers: C# allows combining public, internal, protected, and private (as seen in protected internal and private protected) to fine-tune accessibility.

• Impact on Maintenance: Proper use of access modifiers can make your codebase easier to understand and maintain, as it clearly delineates what parts of your system should be visible to external developers.

Summary Table

| Modifier | Accessibility Scope | |--------------------|--------------------------------------------------| | public | Any assembly that references it | | private | Only within the class | | protected | Within the class and derived classes | | internal | Within the containing assembly | | protected internal | With derived classes both inside and outside assembly, but not outside without derivation | | private protected | Within the same assembly or derived classes only |