C# - Protected Internal With Real Time Use case

Protected Internal With Real Time Use cases in C#

Let’s explain protected internal with a real-world example using an Employee class.

Example

Imagine you're building a system where the Employee class contains certain private details, such as salary, that should not be exposed to external users. However, there are scenarios where you want to allow derived classes to access those details, and also allow access within the same assembly.

You want to expose the Salary property to derived classes (even if they are in another assembly) and within the same assembly, but not allow direct access from other classes that are not part of the inheritance hierarchy.

Employee Class with protected internal Example:

Base Class in Core Assembly (Employee.cs):

using System;

public class Employee
{
    // Protected Internal property, accessible within the same assembly or in derived classes.
    protected internal decimal Salary { get; set; }

    // Constructor to initialize the Employee details
    public Employee(string name, decimal salary)
    {
        Name = name;
        Salary = salary;
    }

    // Public property for the employee's name
    public string Name { get; set; }

    // Method to display basic employee information
    public void DisplayInfo()
    {
        Console.WriteLine($"Employee: {Name}, Salary: {Salary}");
    }

    // Protected Internal method to update salary, accessible within the same assembly or in derived classes
    protected internal void UpdateSalary(decimal newSalary)
    {
        Salary = newSalary;
    }
}

Derived Class in the Same or Another Assembly (Manager.cs):

Now, let’s say you are working in another class or assembly that derives from Employee (perhaps for a Manager role). The derived class will have access to the Salary property and the UpdateSalary method due to the protected internal access modifier.

using System;

public class Manager : Employee
{
    // Constructor for Manager class, calling base class constructor
    public Manager(string name, decimal salary) : base(name, salary)
    {
    }

    // Method specific to Manager to provide a raise to an employee
    public void GiveRaise(decimal raiseAmount)
    {
        // Accessing protected internal property Salary in the derived class
        UpdateSalary(Salary + raiseAmount);
        Console.WriteLine($"{Name}'s new salary is {Salary}");
    }
}

Main Program to Test the Behavior (Program.cs):

Let’s simulate how the system would behave in a real-world scenario where both the Employee and Manager classes are used.

using System;

class Program
{
    static void Main()
    {
        // Creating an employee instance in the same assembly
        Employee emp1 = new Employee("John Doe", 50000);
        emp1.DisplayInfo(); // Employee: John Doe, Salary: 50000

        // Creating a Manager instance (Derived class)
        Manager mgr1 = new Manager("Alice Smith", 70000);
        mgr1.DisplayInfo(); // Employee: Alice Smith, Salary: 70000

        // Giving a raise to the manager
        mgr1.GiveRaise(5000); // Alice Smith's new salary is 75000
    }
}

Explanation:

Employee Class:

• The Salary property is protected internal, meaning:
• It can be accessed by derived classes (like Manager), even if they are in another assembly.
• It can also be accessed within the same assembly (i.e., any class in the same assembly as Employee).
• The UpdateSalary method is also protected internal, meaning it can be called by derived classes and by any class within the same assembly. This provides a controlled way to modify the Salary property

Manager Class:

• The Manager class derives from Employee and uses the protected internal method UpdateSalary to change the salary of a Manager object.
• This shows how a derived class (like Manager) can access and modify properties and methods that are marked as protected internal

Main Program:

In the Main method, the Employee and Manager objects are created and tested.

• The Manager class can access and modify the Salary property of the base Employee class through the protected internal method UpdateSalary.
• The program allows a raise to be applied to a manager’s salary by calling the GiveRaise method, which demonstrates the use of protected internal for both fields and methods.

Key Points about protected internal:

1. Access within the Same Assembly:

Both the Salary property and the UpdateSalary method are accessible within the same assembly, so they can be used directly in other classes that are part of the same project or assembly.

2. Access in Derived Classes in Other Assemblies:

Even though Salary is a protected internal property, it can be accessed in derived classes that are in another assembly (as shown in the Manager class). This is particularly useful in scenarios where you want to extend functionality (e.g., plugins, subclasses) but still maintain some control over how data is accessed and modified.

3. Not Accessible Outside the Assembly or Inheritance Hierarchy:

The Salary property and UpdateSalary method cannot be accessed by just any class outside the Employee or derived classes. This keeps sensitive data like salary encapsulated and secure.

When to Use protected internal:

• Encapsulation: You want to hide implementation details but still allow some controlled flexibility for both derived classes and other code within the same assembly.
• Extensibility: You allow derived classes (even if they are in different assemblies) to access certain functionality but keep it protected from being accessed by any arbitrary class.
• Internal Utility: When you have utility methods that are critical to the functionality of your class but should not be exposed publicly, while still being available for extension or usage inside the same assembly.