C# Encapsulation

Encapsulation is one of the core principles of Object-Oriented Programming (OOP) in C#. It refers to the bundling of data (variables) and methods (functions) that operate on the data into a single unit, typically a class, while restricting access to certain details. This helps protect the integrity of the object by exposing only necessary components to the outside world and hiding internal workings. Encapsulation promotes modular, maintainable, and secure code.

In this tutorial, we will explore the concept of encapsulation, how it is applied in C# with examples, its real-world use cases, and a detailed explanation followed by key takeaways and a summary.

What is Encapsulation in C#?

Encapsulation in C# is the concept of wrapping the data (fields) and the methods that operate on the data into a single class while restricting direct access to some of the object’s components. It is the practice of hiding the implementation details of a class and only exposing a controlled interface to the user.

Encapsulation ensures that the internal representation of an object is hidden from the outside. Only the public members (methods and properties) are exposed to external objects, while internal details (such as private fields) remain hidden and cannot be directly accessed.

How Encapsulation Works in C#

In C#, encapsulation is typically achieved using access modifiers (private, public, protected, internal) and properties (getters and setters). The most common practice is to declare class fields as private and provide controlled access to them through public properties or methods.

Access Modifiers:

• Private: Only accessible within the class itself.
• Public: Accessible from outside the class.
• Protected: Accessible within the class and by derived classes.
• Internal: Accessible only within the same assembly.

Example Structure

class Person
{
    private string name; // Field is private, hidden from outside

    // Public property provides controlled access to the name field
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

In the example above, the field name is encapsulated (hidden) using the private modifier, and we provide access to it through a public property Name.

Examples of Encapsulation in C#

Example 1: Basic Encapsulation Using Properties

class BankAccount
{
    private double balance;  // Encapsulated field

    // Public property to access balance
    public double Balance
    {
        get { return balance; }
        private set { balance = value; }
    }

    public BankAccount(double initialBalance)
    {
        balance = initialBalance; // Constructor sets initial balance
    }

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

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

In this example:

• The balance field is private and cannot be accessed directly.
• Controlled access to the balance is provided through the Balance property (read-only outside the class).
• The Deposit and Withdraw methods provide controlled ways to manipulate the balance.

Usage:

BankAccount account = new BankAccount(1000);
account.Deposit(200);
Console.WriteLine(account.Balance); // Output: 1200
account.Withdraw(500);
Console.WriteLine(account.Balance); // Output: 700

Example 2: Encapsulation with Input Validation

Encapsulation also allows us to enforce input validation through public methods.

class Employee
{
    private string name;  // Encapsulated field

    // Public property with validation in the setter
    public string Name
    {
        get { return name; }
        set
        {
            if (!string.IsNullOrEmpty(value))
                name = value;
            else
                throw new ArgumentException("Name cannot be empty.");
        }
    }

    public Employee(string name)
    {
        Name = name; // Using property to set value, enforces validation
    }
}

Here, the Name property includes validation, preventing an invalid state (an empty name) from being set.

Real-World Example

Example: Encapsulation in a Car Class

Let's consider an example where encapsulation is applied in a Car class. In a car, certain functionalities, such as starting the engine, are hidden from the user, while others, like setting the speed, are exposed via methods or properties.

class Car
{
    private bool engineStarted; // Private field encapsulated
    private int speed;

    // Public method to start the engine
    public void StartEngine()
    {
        engineStarted = true;
        Console.WriteLine("Engine started.");
    }

    // Public method to stop the engine
    public void StopEngine()
    {
        engineStarted = false;
        Console.WriteLine("Engine stopped.");
    }

    // Public property to control car's speed
    public int Speed
    {
        get { return speed; }
        set
        {
            if (engineStarted)
            {
                if (value >= 0 && value <= 200)
                    speed = value;
                else
                    Console.WriteLine("Speed must be between 0 and 200.");
            }
            else
            {
                Console.WriteLine("Start the engine first.");
            }
        }
    }
}

Here:

• The engineStarted field is private and only controlled via StartEngine and StopEngine methods.
• The Speed property is exposed to the user, but speed changes are allowed only when the engine is started.

Usage:

Car myCar = new Car();
myCar.Speed = 50;  // Output: Start the engine first.
myCar.StartEngine();  // Output: Engine started.
myCar.Speed = 80;  // Sets speed to 80
Console.WriteLine(myCar.Speed);  // Output: 80
myCar.StopEngine();  // Output: Engine stopped.

In this real-world example, the car’s internal workings (engine state) are hidden, and only the necessary functionalities (like starting the engine and setting the speed) are exposed.

Key Takeaways

1. Hiding Implementation: Encapsulation hides the internal details of an object, making it easier to work with and protecting the object from unwanted changes.
2. Controlled Access: By using access modifiers and properties, encapsulation provides controlled access to an object's data, ensuring data integrity and validation.
3. Improves Maintainability: Encapsulation leads to better maintainability since changes to the internal implementation don’t affect the outside code that uses the class.
4. Reusability: Encapsulated classes can be reused and modified independently without affecting the other parts of the system.
5. Security: Sensitive data is protected by encapsulating it in private fields and exposing only necessary functionality via public methods or properties.

Summary

Encapsulation in C# is the practice of keeping data safe and hidden from direct access by external components while providing public interfaces (methods and properties) for necessary interaction. It allows for better control, security, and maintenance of code. By using encapsulation, you ensure that the object maintains a valid state, and changes to the object's internal workings do not affect the rest of the program.

In real-world applications, encapsulation is used in various scenarios, such as managing bank accounts, handling cars' internal systems, or creating more complex classes where some functionality needs to be protected while others are exposed. The key principle behind encapsulation is data hiding and controlled access through properties and methods.

When you design classes with encapsulation in mind, your code becomes easier to understand, maintain, and scale.