Access Modifiers in C#

Access modifiers in C# provide control over visibility and access to the members of classes and structures.

Access modifiers are the way to implement encapsulation in C#, one of the pillars of object-oriented programming.

Access Modifiers

Members of the base class can have different levels of accessibility: public, protected, internal, protected internal, and private.

The accessibility of these members determines how they can be used by the derived class.

Public Modifier

The public modifier allows members to be accessible from anywhere in the code, without restrictions. It is useful for defining the public API of a class, allowing other components to interact with it.

public class Vehicle
{
    public string Brand { get; set; }
    public string Model { get; set; }

    public void Start()
    {
        Console.WriteLine($"{Brand} {Model} has started.");
    }
}

Private Modifier

The private modifier restricts access to members only to the class or structure that defines them. This means that no other code outside of this class can access these members, promoting encapsulation and protection of internal data.

public class BankAccount
{
    private decimal balance;

    public BankAccount(decimal initialBalance)
    {
        balance = initialBalance;
    }

    public void Deposit(decimal amount)
    {
        balance += amount;
    }

    public decimal GetBalance()
    {
        return balance;
    }
}

Internal Modifier

The internal modifier restricts access to members to any code within the same assembly (i.e., the same project or library). This is useful for components that need to be accessible throughout the application, but not publicly exposed to other assemblies.

internal class InternalService
{
    internal void Execute()
    {
        Console.WriteLine("Executing internal service.");
    }
}

Protected Modifier

The protected modifier allows members to be accessible within their class and by any derived class. This is useful for defining members that should be accessible for inheritance but not publicly exposed.

public class Animal
{
    protected void Eat()
    {
        Console.WriteLine("The animal is eating.");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Eat(); // Access allowed to the protected method of the base class
        Console.WriteLine("The dog is barking.");
    }
}

Protected Internal Modifier

You can combine internal and protected to allow access within the same assembly and in derived classes.

public class Base
{
    protected internal void Method()
    {
        Console.WriteLine("Method accessible from the same assembly or derived classes.");
    }
}

public class Derived : Base
{
    public void CallMethod()
    {
        Method(); // Access allowed
    }
}