C# Access Modifiers

Last modified on: October 20, 2024

<h3>C# Access Modifiers: Understanding Visibility and Encapsulation</h3>
<p>Access modifiers in C# are keywords that define the visibility and accessibility of classes, methods, properties, and other members. They play a crucial role in encapsulation, which is a fundamental principle of object-oriented programming. By controlling access to class members, you can protect your data and ensure that only authorized parts of your code can interact with it.</p>
<hr />
<h3>1. <strong>Types of Access Modifiers</strong></h3>
<p>C# provides several access modifiers that can be applied to class members:</p>
<ol>
<li><strong>Public</strong></li>
<li><strong>Private</strong></li>
<li><strong>Protected</strong></li>
<li><strong>Internal</strong></li>
<li><strong>Protected Internal</strong></li>
<li><strong>Private Protected</strong></li>
</ol>
<p>Let&rsquo;s explore each of these in detail.</p>
<hr />
<h3>2. <strong>Public</strong></h3>
<p>Members declared as <code>public</code> are accessible from any other code in the same assembly or another assembly that references it. Public access is the least restrictive access level.</p>
<h4>Example: Public Access Modifier</h4>
<pre class="language-csharp"><code>public class Car
{
    public string Make;
    public string Model;
    public int Year;

public void DisplayInfo()
    {
        Console.WriteLine($"Car: {Year} {Make} {Model}");
    }
}

// Accessing public members
Car myCar = new Car();
myCar.Make = "Toyota";
myCar.Model = "Camry";
myCar.Year = 2022;
myCar.DisplayInfo(); // Output: Car: 2022 Toyota Camry
</code></pre>
<hr />
<h3>3. <strong>Private</strong></h3>
<p>Members declared as <code>private</code> are accessible only within the same class. This is the most restrictive access level, which helps encapsulate and protect data from outside interference.</p>
<h4>Example: Private Access Modifier</h4>
<pre class="language-csharp"><code>public class Car
{
    private string make;
    private string model;
    private int year;

public void SetCarInfo(string make, string model, int year)
    {
        this.make = make;
        this.model = model;
        this.year = year;
    }

public void DisplayInfo()
    {
        Console.WriteLine($"Car: {year} {make} {model}");
    }
}

// Accessing private members
Car myCar = new Car();
myCar.SetCarInfo("Honda", "Civic", 2021);
myCar.DisplayInfo(); // Output: Car: 2021 Honda Civic
</code></pre>
<p>In this example, the fields <code>make</code>, <code>model</code>, and <code>year</code> are private, ensuring they can only be modified through the public method <code>SetCarInfo</code>.</p>
<hr />
<h3>4. <strong>Protected</strong></h3>
<p>Members declared as <code>protected</code> are accessible within their class and by derived classes. This allows for inheritance while still protecting members from being accessed outside of the inheritance hierarchy.</p>
<h4>Example: Protected Access Modifier</h4>
<pre class="language-csharp"><code>public class Vehicle
{
    protected string Make;
    protected string Model;

protected void DisplayInfo()
    {
        Console.WriteLine($"Vehicle: {Make} {Model}");
    }
}

public class Car : Vehicle
{
    public void SetCarInfo(string make, string model)
    {
        Make = make;
        Model = model;
    }

public void ShowInfo()
    {
        DisplayInfo(); // Accessing protected method
    }
}

// Using protected members
Car myCar = new Car();
myCar.SetCarInfo("Ford", "Mustang");
myCar.ShowInfo(); // Output: Vehicle: Ford Mustang
</code></pre>
<p>In this example, the <code>Make</code> and <code>Model</code> fields are protected, allowing access in the derived class <code>Car</code>.</p>
<hr />
<h3>5. <strong>Internal</strong></h3>
<p>Members declared as <code>internal</code> are accessible only within the same assembly. This means they can be accessed by any code in the same project, but not from outside the assembly.</p>
<h4>Example: Internal Access Modifier</h4>
<pre class="language-csharp"><code>internal class Vehicle
{
    internal string Make;
    internal string Model;

internal void DisplayInfo()
    {
        Console.WriteLine($"Vehicle: {Make} {Model}");
    }
}

// Accessing internal members within the same assembly
Vehicle myVehicle = new Vehicle();
myVehicle.Make = "Chevrolet";
myVehicle.Model = "Impala";
myVehicle.DisplayInfo(); // Output: Vehicle: Chevrolet Impala
</code></pre>
<p>In this example, the <code>Vehicle</code> class and its members are internal, allowing access within the same assembly.</p>
<hr />
<h3>6. <strong>Protected Internal</strong></h3>
<p>Members declared as <code>protected internal</code> are accessible within the same assembly and also accessible by derived classes in other assemblies. This modifier combines the features of both <code>protected</code> and <code>internal</code>.</p>
<h4>Example: Protected Internal Access Modifier</h4>
<pre class="language-csharp"><code>public class Vehicle
{
    protected internal string Make;
    protected internal string Model;

protected internal void DisplayInfo()
    {
        Console.WriteLine($"Vehicle: {Make} {Model}");
    }
}

public class Car : Vehicle
{
    public void SetCarInfo(string make, string model)
    {
        Make = make; // Accessing protected internal member
        Model = model;
    }
}

// Accessing protected internal members
Car myCar = new Car();
myCar.SetCarInfo("Nissan", "Altima");
myCar.DisplayInfo(); // Output: Vehicle: Nissan Altima
</code></pre>
<p>In this example, <code>Make</code> and <code>Model</code> can be accessed within the derived class and also within the same assembly.</p>
<hr />
<h3>7. <strong>Private Protected</strong></h3>
<p>Members declared as <code>private protected</code> are accessible only within the same class and derived classes that are in the same assembly. This is a more restrictive version of <code>protected internal</code>.</p>
<h4>Example: Private Protected Access Modifier</h4>
<pre class="language-csharp"><code>public class Vehicle
{
    private protected string Make;

private protected void DisplayInfo()
    {
        Console.WriteLine($"Vehicle: {Make}");
    }
}

public class Car : Vehicle
{
    public void SetMake(string make)
    {
        Make = make; // Accessing private protected member
    }

public void ShowInfo()
    {
        DisplayInfo(); // Accessing private protected method
    }
}

// Accessing private protected members
Car myCar = new Car();
myCar.SetMake("Subaru");
myCar.ShowInfo(); // Output: Vehicle: Subaru
</code></pre>
<p>In this example, <code>Make</code> and <code>DisplayInfo</code> can be accessed within the derived class <code>Car</code>, but not from outside the assembly or outside the class hierarchy.</p>
<hr />
<h3>Conclusion</h3>
<p>Understanding access modifiers is essential for effective object-oriented programming in C#. They provide a way to enforce encapsulation and control the visibility of class members, helping to protect your data and create a clean, maintainable codebase. By using access modifiers appropriately, you can ensure that your classes and their members are used correctly and safely.</p>

Web Technology View More