Encapsulation in C# with Example

What is Encapsulation in C#?

Encapsulation in C# is a mechanism that combines data and methods into a single unit called a class. Encapsulation in C# is like putting your things in a Capsule(class). It's a way to organize and protect your data and methods. You create a class, which is like a capsule, and you put your data (variables) and methods (functions) inside it. This keeps them together and organized. But the cool thing is, you can control who can access and change what's inside the box. You can lock some things away and only allow specific methods to access or modify them.

It enforces the concept of access specifiers, which define the visibility and accessibility of class members. Access specifiers in C# include public, private, protected, and internal.

Explanation of Access Specifiers in C#

Access specifiers in C# are keywords used to specify the visibility or accessibility of classes, methods, properties, and fields within a program. They control which parts of the code can access and interact with certain elements. There are four main access specifiers in C#

• public:
  Allows unrestricted access to a class member from any part of the code.
• private
  Restricts access to a class member only within the same class, making it inaccessible from outside.
• protected:
  Limits access to a class member within the same class and its derived classes, enabling inheritance-related access.
• internal:
  Provides access to a class member within the same assembly (project) but restricts access from outside assemblies.

Example:

Output

Explanation

In the above example, we have a Person class encapsulating the data related to a person's name and age. The name and age variables are declared private, which means they can only be accessed within the class itself. This ensures that the data cannot be modified directly from outside the class.

To set and retrieve the values of the private variables, we define public setter and getter methods (SetName, GetName, SetAge, GetAge). These methods provide controlled access to the private variables and allow us to enforce any necessary validations or logic before modifying or retrieving the values.

In the Main method, we create an instance of the Person class and use the setter methods to set the name and age. Then, we use the getter methods to retrieve and display the values. This way, we can access and manipulate the private data indirectly, maintaining encapsulation.

Implement Encapsulation in C#

Encapsulation can be implemented in C# by following these two key steps:

By Declaring the Variables as Private:

In a class, the data variables that need to be encapsulated should be declared as private. This restricts direct access to the variables from outside the class.

Example:

Output:

In this example, we have a Person class with a private variable name. We use a public setter method SetName to set the name and a public getter method GetName to retrieve the name. The private name variable is encapsulated and can only be accessed and modified through these public methods.

By Defining One Pair of Public Setter and Getter Methods

Public setter methods are used to set the values of private variables, while public getter methods are used to retrieve the values. The class should define these methods to provide controlled access to the encapsulated data.

Example:

Output:

In this example, we have a Person class with a public property Name and a private setter. The Name property can be read from outside the class, but its value can only be set within the class constructor. The private setter encapsulates the Name property, allowing controlled access to its value.

Advantages of Using Encapsulation in C#

• Data Hiding:
  Encapsulation hides the internal details of a class and exposes only the necessary information through public methods. This protects the data from being accessed or modified accidentally, ensuring data integrity and security.
• Modularity and Maintainability:
  Encapsulation allows code to be divided into smaller, independent units (classes). This promotes modularity, making code easier to understand, maintain, and reuse. Changes made within a class have minimal impact on other parts of the codebase.
• Flexibility and Extensibility:
  By encapsulating data and methods, encapsulation provides flexibility in changing the internal implementation of a class without affecting the external code that uses it. It also allows for the addition of new functionality by extending the class, without breaking existing code.
• Code Organization:
  Encapsulation improves code organization and readability. By grouping related data and methods within a class, it becomes easier to navigate and understand the structure of the codebase.