Encapsulation In C#

• "private" members of a class can only be accessed within the class itself.
• "protected" members can be accessed within the class and any derived classes.
• "internal" members can be accessed within the same assembly.

By default, members of a class are private.

For example, if you have a class called "Car" and you want to keep the car's speed private, you would declare the "speed" variable as private, like so:

class Car {
    private int speed;
    ...
}

You can then provide public methods to access and modify the speed variable, known as getter and setter method:

class Car {
    private int speed;
    public int Speed {
        get { return speed; }
        set { speed = value; }
    }
    ...
}

This way, the internal representation of the speed variable is hidden from the outside world and can only be accessed through public methods. This encapsulation provides a level of abstraction and control over the data.

How can we implement encapsulation in C# using properties?

In C#, encapsulation can be implemented using properties, which are a special type of class member that provides a way to access and modify the value of a private field. Properties allow you to control access to the internal data of a class while providing a convenient and consistent way for other objects to access and modify that data.

Here is an example of how to implement encapsulation in C# using properties:

class Car {
    private int _speed;
    public int Speed {
        get { return _speed; }
        set { _speed = value; }
    }
}

In this example, the private field "_speed" is encapsulated by the public property "Speed." The "get" accessor of the property allows other objects to retrieve the value of the private field, while the "set" accessor allows them to modify it.

You can also use the "readonly" keyword to make the property read-only:

class Car {
    private readonly int _speed;
    public int Speed {
        get { return _speed; }
    }
}

This way, you can only get the value of the property but not set it.

Additionally, you can use the "private set" to make the setter private and only accessible inside the class.

class Car {
    public int Speed { get; private set; }
}

By using properties, you can implement encapsulation in C# in a way that is both efficient and easy to understand, making your code more maintainable and less error-prone.

Here is a detailed article on Properties In C# (c-sharpcorner.com).

Summary

Encapsulation is one of the basic features of object-oriented programming (OOP) languages. The code in this article taught you how to implement encapsulation in C#.

Continue reading more on object-oriented programming: Object Oriented Programming In C# (c-sharpcorner.com)