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.
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.
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.
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.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.
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:
balance field is private and cannot be accessed directly.balance is provided through the Balance property (read-only outside the class).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
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.
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:
engineStarted field is private and only controlled via StartEngine and StopEngine methods.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.
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.