Encapsulation and information hiding are fundamental concepts in object-oriented programming (OOP) that help to manage complexity and improve code maintainability. In C#, these principles enable developers to create well-structured, modular applications.

Encapsulation

Encapsulation is the practice of bundling the data (attributes) and methods (functions) that operate on that data into a single unit, known as a class. This allows an object to restrict access to its internal state and only expose a controlled interface for interaction. Encapsulation provides several benefits:

1. Data Hiding: It restricts direct access to the object’s attributes, preventing external code from modifying them directly. This can help maintain the integrity of the data.
2. Controlled Access: By exposing methods to interact with the internal state, a class can enforce rules and validation, ensuring that its state remains valid.
3. Modularity: It encourages modular design, where classes can be developed, tested, and maintained independently.

Example of Encapsulation

public class BankAccount
{
    private decimal balance; // Private field

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

    // Public method to deposit money
    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            balance += amount;
        }
    }

    // Public method to withdraw money
    public void Withdraw(decimal amount)
    {
        if (amount > 0 && amount <= balance)
        {
            balance -= amount;
        }
    }

    // Public method to check the balance
    public decimal GetBalance()
    {
        return balance;
    }
}

In the example above:

• The balance field is private, so it cannot be accessed directly from outside the BankAccount class.
• The Deposit and Withdraw methods control how the balance can be modified, ensuring that invalid operations cannot occur.

Information Hiding

Information hiding is closely related to encapsulation but emphasizes the principle of exposing only necessary details while keeping other details hidden from the user. This concept promotes loose coupling and reduces dependencies between classes.

1. Implementation Details: By hiding implementation details, changes to the internal workings of a class do not affect other parts of the program that rely on it.
2. Interface Exposure: Only necessary methods and properties are exposed to users of the class, reducing the risk of unintended interactions.

Example of Information Hiding

In the BankAccount example, the internal structure and methods used to manage the balance are hidden from users. Only the methods for depositing, withdrawing, and checking the balance are exposed, which keeps the implementation details encapsulated.

Access Modifiers in C#

C# provides several access modifiers to control the visibility of class members:

1. Public: Members are accessible from any other code.
2. Private: Members are accessible only within the containing class.
3. Protected: Members are accessible within the containing class and by derived classes.
4. Internal: Members are accessible within the same assembly.
5. Protected Internal: Members are accessible within the same assembly or from derived classes.

These access modifiers allow developers to enforce encapsulation and information hiding effectively.

Summary

• Encapsulation combines data and methods in a single unit (class), providing a controlled interface for interacting with the object’s state.
• Information hiding restricts access to the internal workings of a class, exposing only what is necessary for users to interact with it.
• Together, these principles enhance the maintainability, reliability, and flexibility of code in C#. By leveraging access modifiers and designing classes thoughtfully, developers can create robust applications that minimize dependencies and reduce the risk of errors.