C# Tutorial 7.3: Encapsulation

 Encapsulation is one of the fundamental principles of object-oriented programming (OOP) in C#. It refers to the bundling of data and the methods that operate on that data into a single unit, known as a class. Encapsulation helps in hiding the internal details of a class and exposing only what is necessary. This tutorial will guide you through the concept of encapsulation in C#.

1. Understanding Encapsulation:

Encapsulation involves the bundling of data (attributes or fields) and the methods (functions) that operate on that data into a single unit, known as a class. It helps in restricting access to some of the object's components, protecting the integrity of the object's internal state.

2. Creating a Simple Class:

Let's start by creating a simple class in C# that demonstrates encapsulation.

public class Person
{
    // Private fields (data)
    private string name;
    private int age;
    // Public methods to access and modify the data
    public void SetName(string newName)
    {
        name = newName;
    }
    public string GetName()
    {
        return name;
    }
    public void SetAge(int newAge)
    {
        if (newAge > 0)
        {
            age = newAge;
        }
        else
        {
            Console.WriteLine("Age must be a positive value.");
        }
    }
    public int GetAge()
    {
        return age;
    }
}

3. Access Modifiers:

In the above example, the name and age fields are declared as private. This means that they can only be accessed within the Person class. The methods SetName, GetName, SetAge, and GetAge are used to manipulate and access these private fields. These methods are declared as public, allowing them to be accessed from outside the class.

4. Using the Class:

Now, let's use the Person class in a program.

class Program
{
    static void Main()
    {
        // Create an instance of the Person class
        Person person = new Person();
        // Set and get the name
        person.SetName("John Doe");
        Console.WriteLine($"Name: {person.GetName()}");
        // Set and get the age
        person.SetAge(25);
        Console.WriteLine($"Age: {person.GetAge()}");
        // Attempt to set an invalid age
        person.SetAge(-5);
        // Output the age again to see that it remains unchanged
        Console.WriteLine($"Age: {person.GetAge()}");
    }
}

5. Benefits of Encapsulation:

• Data Hiding: Encapsulation hides the internal details of the class, allowing changes to be made to the implementation without affecting the code that uses the class.
• Controlled Access: By providing public methods to access and modify data, you can control how external code interacts with the class, enforcing rules and validation.

6. Conclusion:

Encapsulation is a crucial concept in C# and OOP in general. It helps in creating modular and maintainable code by hiding the implementation details and exposing a well-defined interface.

By following the principles of encapsulation, you can design classes that are more robust, flexible, and easier to understand and maintain.