Mastering Encapsulation with Properties | CodeSignal Learn

Mastering Encapsulation with Properties | CodeSignal Learn

Mastering Encapsulation with Properties

Welcome back! In the previous lesson, we delved into constructors and their significance in initializing objects in C#. You saw how constructors set up your objects with valid data, ensuring they are ready for action. Now, let's take a step further into a crucial aspect of Object-Oriented Programming: encapsulation through properties.

What You'll Learn

In this lesson, we will focus on encapsulation — one of the four fundamental concepts of Object-Oriented Programming. Encapsulation is all about restricting direct access to certain components of an object, making your code more modular and less prone to errors. We achieve this by using properties, which serve as a bridge to access private attributes indirectly.

Understanding Public vs Private

Before diving into encapsulation, it's essential to understand the difference between public and private access modifiers: Public: This access modifier means that the member (attribute or method) is accessible from anywhere in your code. Any object or function, whether inside or outside the class, can access and modify a public member. Private: This access modifier restricts access to the member strictly within the class it is defined. It cannot be accessed directly from outside the class, providing a way to hide and protect the internal state of an object. By using these access modifiers appropriately, you can control the level of access to different parts of your code, enhancing security and maintainability.

What Are Properties?

Properties are special members of a class that provide a flexible mechanism to read, write, or compute the values of private fields. They look like public data members but are actually special methods called accessors. There are two types of accessors: Get Accessor: This is used to return the value of the private field. Set Accessor: This is used to assign a new value to the private field. By using properties, you can control how values are set or retrieved, adding an extra layer of validation or logic if needed. This encapsulation helps in protecting the integrity of your data.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Let's start by defining a class that uses encapsulation. Encapsulation involves keeping an object's data (attributes) private and providing public methods to access and update that data. This way, we can control how our data is accessed and modified. class Spaceship {// Private attribute: cannot be accessed directly from outside the class private string name; // Constructor to initialize the private attribute public Spaceship(string name) {this.name = name;} // Public property for accessing and modifying the private attribute public string Name {get { return name; } set { name = value; }}} In this code, the name attribute is private, which means it can't be accessed directly from outside the Spaceship class. Instead, we use a public property Name to get (read) and set (update) the name attribute. This allows us to control how the name is accessed and modified, ensuring the object's internal state remains consistent.

Using the Class in a Program

Now, let's see how we can use this Spaceship class in a simple program. We'll create an instance of the class and interact with the private attribute through its property. class Program {static void Main() {// Create an object of the Spaceship class using the constructor Spaceship myShip = new Spaceship("Voyager-1"); /// Print the initial name attribute using the property Console.WriteLine(myShip.Name); // Change the name attribute using the property set method myShip.Name = "Explorer-2"; // Print the updated name attribute using the property Console.WriteLine(myShip.Name);}} In this example, we see how encapsulation works in practice. We create a Spaceship object and set its name through the constructor. Although we can't directly access the name attribute, we can use the Name property to read and update it. This protects the internal state of the Spaceship object, only allowing controlled access to its name . This approach helps prevent errors and keeps our code more reliable.

C#

class Spaceship 
{
    // Private attribute: cannot be accessed directly from outside the class
    private string name;

    // Constructor to initialize the private attribute
    public Spaceship(string name)
    {
        this.name = name;
    }

    // Public property for accessing and modifying the private attribute
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

C#

class Program
{
    static void Main()
    {
        // Create an object of the Spaceship class using the constructor
        Spaceship myShip = new Spaceship("Voyager-1");

        /// Print the initial name attribute using the property
        Console.WriteLine(myShip.Name);

        // Change the name attribute using the property set method
        myShip.Name = "Explorer-2";

        // Print the updated name attribute using the property
        Console.WriteLine(myShip.Name);
    }
}