Encapsulation in C#

Encapsulation is one of the core principles of object-oriented programming (OOP). It refers to the practice of binding data (fields) and the methods that operate on that data into a single unit, while restricting direct access to some components. This ensures controlled interaction with an object’s internal state.

Key Concepts

• Encapsulation hides the internal representation of an object and exposes only necessary operations.
• Fields are often kept private while access is provided through public properties or methods.
• It improves data security, code maintainability and flexibility.
• Access modifiers (private, public, protected, internal) control visibility of members.

Example:

using System;

class Account
{
    private double balance; // hidden field

    public void Deposit(double amount)
    {
        if (amount > 0)
            balance += amount;
    }

    public void Withdraw(double amount)
    {
        if (amount <= balance)
            balance -= amount;
    }

    public double GetBalance()
    {
        return balance;
    }
}

class GFG
{
    static void Main()
    {
        Account acc = new Account();
        acc.Deposit(500);
        acc.Withdraw(200);
        Console.WriteLine("Balance: " + acc.GetBalance());
    }
}

Balance: 300

Explanation:

• balance is private and cannot be accessed directly from outside.
• The class provides controlled methods (Deposit, Withdraw, GetBalance) to interact with the field.

Encapsulation Using Properties

C# provides properties to simplify encapsulation, acting like smart getters and setters.

using System;

class Student
{
    private string name; // private field

    public string Name
    {
        get { return name; }
        set 
        { 
            if (!string.IsNullOrEmpty(value))
                name = value; 
        }
    }
}
class Program
{
    static void Main()
    {
        Student s = new Student();
        s.Name = "Alex";
        Console.WriteLine("Student Name: " + s.Name);
    }
}

Student Name: Alex

Explanation:

• The field name is private.
• The Name property controls how values are set and retrieved.
• This improves flexibility compared to public fields.

Advantages

• Data Protection: Prevents unauthorized access to fields.
• Controlled Access: Exposes only required operations.
• Code Flexibility: Internal implementation can change without affecting external code.
• Maintainability: Reduces coupling between classes.

Disadvantages

• Using getters and setters adds extra code compared to accessing fields directly.
• Accessing data through methods may be a bit slower than direct access.
• Since data is hidden, it can sometimes be difficult to quickly inspect or change values during debugging.