Lesson 5 — Encapsulation in C#

Encapsulation is the first and most important pillar of OOP.
It helps you wrap data (variables) and behavior (methods) inside a single unit — the class — and protects that data from unauthorized access.

In simple words:

Encapsulation = Data Hiding + Controlled Access

This creates secure, clean, and maintainable code in C# applications.

🌟 What is Encapsulation?

Encapsulation means bundling data and methods together into a class and restricting direct access to the internal data.

In C#, encapsulation is achieved using:

• private fields (hidden data)
• public properties / methods (controlled access)

🔒 Real-World Analogy of Encapsulation

Think about your Mobile Phone.

You click a button → it performs an action.
But you cannot see or modify the internal hardware.

✔ You can use the phone
❌ You cannot directly touch its circuit board

This is encapsulation.

Similarly in C#:

• User sees only the public interface
• Internal logic remains protected

💡 Why Encapsulation is Important in C#

✔ Prevents accidental changes to data

✔ Protects sensitive information

✔ Makes code safe and secure

✔ Allows validation before setting values

✔ Makes code easier to maintain

✔ Ensures controlled interaction with objects

🧱 Basic Encapsulation Example (Before vs After)

🔴 Without Encapsulation — Bad Programming

public class Student
{
    public string Name;
    public int Age;
}

Anyone can change the data directly, even with invalid values:

Student s = new Student();
s.Age = -10;   // invalid age allowed!

This is unsafe.

🟢 With Encapsulation — Good Programming

public class Student
{
    private int age;        // private field

    public int Age          // public property
    {
        get { return age; }
        set
        {
            if (value > 0 && value <= 120)
                age = value;
            else
                Console.WriteLine("Invalid age!");
        }
    }
}

Using the class:

Student s = new Student();
s.Age = 20;     // valid
s.Age = -10;    // Invalid age!

✔ What happened?

• Age is protected
• Validation is applied
• Only safe values are stored

This is real encapsulation.

🔒 Encapsulation Using Properties (Modern C#)

Modern C# uses automatic properties:

public class Car
{
    public string Brand { get; set; }
    public int Speed { get; private set; }  // private setter
}

Here:

• Brand can be read and written
• Speed can only be read
• Speed is internally controlled by the class

✨ Practical Encapsulation Example — Bank Account

A bank account must hide balance and allow controlled access.

public class BankAccount
{
    private double balance;  // hidden

    public double Balance    // read-only
    {
        get { return balance; }
    }

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

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

✔ Protected balance

✔ Controlled deposit / withdrawal

✔ No direct modification

🧠 Key Points to Remember

Encapsulation is implemented using:

✔ Private fields

✔ Public properties (get/set)

✔ Public methods

✔ Access modifiers (private, public, protected, internal)

Encapsulation ensures safer and cleaner code.

📘 Access Modifiers That Enable Encapsulation

Encapsulation makes use of private + public most of the time.

🔍 Encapsulation vs Data Hiding

These two are often confused.

Simple:

Data hiding is a part of encapsulation.

📝 Mini Exercise (Practice Task)

Create a class:

Class Name: Employee
Private field: salary
Public property: Salary with validation
Rules:

• Salary cannot be negative
• Salary cannot exceed ₹10,00,000

Try creating employee objects with valid & invalid salaries.

🔍 FAQs

Q1: Why is encapsulation needed?

To protect data and ensure only safe changes happen.

Q2: What happens if I don’t use encapsulation?

Your code becomes unsafe, unstructured, and prone to errors.

Q3: Is encapsulation the same as abstraction?

No —

• Encapsulation = How data is protected
• Abstraction = What details to show/hide

Q4: Can properties exist without private fields?

Yes, using auto-properties — but encapsulation is stronger when you add validation.

🎉 Conclusion

Encapsulation is all about:

• Protecting data
• Providing controlled access
• Keeping classes safe and clean
• Making your application maintainable

You now understand the first pillar of OOP in C#.