Access modifiers in C# are keywords that define the accessibility level of classes, methods, variables, and other members. They play a crucial role in the encapsulation concept of Object-Oriented Programming (OOP), allowing you to control which parts of your code are accessible from outside their scope. This improves code organization, maintainability, and security by hiding the implementation details that should not be exposed unnecessarily.
C# provides several access modifiers to fine-tune the visibility of class members. Each modifier has its own purpose and usage depending on the design of your program.
In this tutorial, we’ll explore the different access modifiers in C#, provide examples of each, and discuss their use cases in real-world applications.
Access modifiers are special keywords that determine the visibility of classes and their members. In C#, the most commonly used access modifiers are:
Public: Accessible from anywhere.Private: Accessible only within the class.Protected: Accessible within the class and its derived classes.Internal: Accessible within the same assembly.Protected Internal: A combination of protected and internal.Private Protected: A combination of private and protected.These modifiers help encapsulate data, ensuring that the internal workings of a class are hidden, and only specific members are exposed to other parts of the program.
PublicThe public modifier allows members to be accessible from any part of the program. If a class, method, or property is marked as public, it can be accessed by other classes, including those outside the assembly.
public class Person
{
public string Name;
public int Age;
public void Introduce()
{
Console.WriteLine($"Hello, my name is {Name}, and I am {Age} years old.");
}
}
Person person = new Person();
person.Name = "John";
person.Age = 30;
person.Introduce(); // Output: Hello, my name is John, and I am 30 years old.
In the above example, the Name, Age, and Introduce method are accessible anywhere because they are marked as public.
public when you want certain members of a class to be universally accessible, such as utility functions or global variables.PrivateThe private modifier restricts access to members only within the class in which they are declared. These members cannot be accessed or modified from outside the class.
public class BankAccount
{
private double balance;
public void Deposit(double amount)
{
balance += amount;
}
public void ShowBalance()
{
Console.WriteLine($"Your balance is {balance}");
}
}
BankAccount account = new BankAccount();
account.Deposit(1000);
// account.balance = 500; // This would cause a compilation error, as 'balance' is private.
account.ShowBalance(); // Output: Your balance is 1000
Here, the balance field is marked as private, meaning it can only be modified by the class's methods (Deposit, ShowBalance).
private for data that should only be accessible within the class, ensuring that its value cannot be changed or read from outside the class.ProtectedThe protected modifier allows members to be accessed within the class in which they are declared, as well as in any class that inherits from it.
public class Animal
{
protected string sound;
public void MakeSound()
{
Console.WriteLine(sound);
}
}
public class Dog : Animal
{
public Dog()
{
sound = "Bark!";
}
}
Dog dog = new Dog();
dog.MakeSound(); // Output: Bark!
In this example, the sound field is marked as protected, so it can be accessed and modified by the Dog class, which inherits from Animal.
protected when you want to allow derived classes to access and modify specific members of a base class but restrict access from outside classes.InternalThe internal modifier makes a member accessible only within the same assembly. This means that any class or member marked as internal cannot be accessed by code in a different assembly (e.g., a separate project or library).
internal class Employee
{
internal string Position;
internal double Salary;
internal void DisplayDetails()
{
Console.WriteLine($"Position: {Position}, Salary: {Salary}");
}
}
If the Employee class and its members are marked as internal, they can only be accessed within the same assembly (e.g., within the same project or DLL).
internal when you want to hide implementation details from other assemblies, while allowing full access within the same assembly.Protected InternalThe protected internal modifier is a combination of protected and internal. It allows access from any class in the same assembly or from any derived class, even if the derived class is in a different assembly.
public class BaseClass
{
protected internal void ShowMessage()
{
Console.WriteLine("Protected Internal Method");
}
}
public class DerivedClass : BaseClass
{
public void DisplayMessage()
{
ShowMessage(); // Accessible because it's a derived class.
}
}
In this example, ShowMessage can be accessed by any class in the same assembly or any derived class, even if it's in a different assembly.
protected internal when you want members to be accessible within the same assembly or through inheritance across different assemblies.Private ProtectedThe private protected modifier is a combination of private and protected. It restricts access to the containing class and derived classes within the same assembly.
public class BaseClass
{
private protected void ShowMessage()
{
Console.WriteLine("Private Protected Method");
}
}
class DerivedClass : BaseClass
{
public void DisplayMessage()
{
ShowMessage(); // Accessible within the derived class in the same assembly.
}
}
In this example, the ShowMessage method is accessible in derived classes but only within the same assembly.
private protected when you want to limit access to the same assembly and derived classes but prevent external code from accessing it.Internal is the default access modifier for classes.internal by default.Private is the default access modifier for class members.private by default.PublicPublic methods in service classes can be used to expose an interface to external code (e.g., a public API).PrivateProtectedProtected methods and properties allow derived classes to extend the base class while maintaining encapsulation.Internalinternal to hide details from other assemblies, exposing only what's necessary.Protected Internalinternal use and inheritance are common, protected internal allows maximum flexibility while maintaining some level of protection.Private ProtectedPublic: Most permissive, allows access from anywhere.Private: Most restrictive, allows access only within the class.Protected: Accessible within the class and its derived classes.Internal: Accessible only within the same assembly.Protected Internal: A blend of protected and internal, allows access in the same assembly or from derived classes.Private Protected: Combines private and protected, allows access within derived classes in the same assembly.By properly using access modifiers, you can create well-encapsulated, maintainable, and secure code that restricts access to sensitive data and functionality, while exposing only what is necessary.