C# - Encapsulation

Previous
Quiz
Next

Encapsulation is defined 'as the process of enclosing one or more items within a physical or logical package'. Encapsulation, in object oriented programming methodology, prevents access to implementation details.

Abstraction and encapsulation are related features in object oriented programming. Abstraction allows making relevant information visible and encapsulation enables a programmer to implement the desired level of abstraction.

Encapsulation is implemented by using access specifiers. An access specifier defines the scope and visibility of a class member. C# supports the following access specifiers −

  • Public
  • Private
  • Protected
  • Internal
  • Protected internal

Public Access Specifier

Public access specifier allows a class to expose its member variables and member functions to other functions and objects. Any public member can be accessed from outside the class.

Example

The following example illustrates the use of a public access specifier in the rectangle class, which displays the area of the rectangle of the rectangle and its display −

using System;
namespace RectangleApplication {
   class Rectangle {
      //member variables
      public double length;
      public double width;
      
      public double GetArea() {
         return length * width;
      }
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

When the above code is compiled and executed, it produces the following result −

Length: 4.5
Width: 3.5
Area: 15.75

  • In the preceding example, the member variables length and width are declared public, so they can be accessed from the function Main() using an instance of the Rectangle class, named r.

  • The member function Display() and GetArea() can also access these variables directly without using any instance of the class.

  • The member functions Display() is also declared public, so it can also be accessed from Main() using an instance of the Rectangle class, named r.

Private Access Specifier

Private access specifier allows a class to hide its member variables and member functions from other functions and objects. Only functions of the same class can access its private members. Even an instance of a class cannot access its private members.

Example

In the following example, we create a rectangle class in which we use the private member variable to hide the member variable −

using System;
namespace RectangleApplication {
   class Rectangle {
      //member variables
      private double length;
      private double width;
      
      public void Acceptdetails() {
         Console.WriteLine("Enter Length: ");
         length = Convert.ToDouble(Console.ReadLine());
         Console.WriteLine("Enter Width: ");
         width = Convert.ToDouble(Console.ReadLine());
      }
      public double GetArea() {
         return length * width;
      }
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }
   //end class Rectangle  
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.Acceptdetails();
         r.Display();
         Console.ReadLine();
      }
   }
}

When the above code is compiled and executed, it produces the following result −

Enter Length:
4.4
Enter Width:
3.3
Length: 4.4
Width: 3.3
Area: 14.52

  • In the preceding example, the member variables length and width are declared private, so they cannot be accessed from the function Main(). The member functions AcceptDetails() and Display() can access these variables. Since the member functions AcceptDetails() and Display() are declared public, they can be accessed from Main() using an instance of the Rectangle class, named r.

Protected Access Specifier

Protected access specifier allows a child class to access the member variables and member functions of its base class. This way it helps in implementing inheritance. We will discuss this in more details in the inheritance chapter.

Example

In this example, we create a rectangle class that calculates the area of a rectangle and we use the protected access specifiers for the length and width −

using System;
namespace RectangleApplication {
   class Rectangle {
      // member variables
      protected double length;
      protected double width;
      
      // Constructor to initialize length and width
      public Rectangle(double length, double width) {
         this.length = length;
         this.width = width;
      }
   
      // Method to calculate area
      double GetArea() {
         return length * width;
      }
   
      // Method to display rectangle details
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle(4.5, 3.5);
         r.Display();
         Console.ReadLine();
      }
   }
}

Following is the output of the above code − 

Length: 4.5
Width: 3.5
Area: 15.75

Internal Access Specifier

Internal access specifier allows a class to expose its member variables and member functions to other functions and objects in the current assembly. In other words, any member with internal access specifier can be accessed from any class or method defined within the application in which the member is defined.

Example

In this example, we showcase how to encapsulate the properties and behaviors of a rectangle in an object-oriented manner using the internal access specifier −

using System;
namespace RectangleApplication {
   class Rectangle {
      //member variables
      internal double length;
      internal double width;
      
      double GetArea() {
         return length * width;
      }
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

When the above code is compiled and executed, it produces the following result −

Length: 4.5
Width: 3.5
Area: 15.75

  • In the preceding example, notice that the member function GetArea() is not declared with any access specifier. Then what would be the default access specifier of a class member if we don't mention any? It is private.

Protected Internal Access Specifier

The protected internal access specifier allows a class to hide its member variables and member functions from other class objects and functions, except a child class within the same application. This is also used while implementing inheritance.

Example

In the following example, we create a rectangle class to calculate the area of the rectangle and use the protected internal access specifiers for the length and width member variable −

using System;
namespace RectangleApplication {
   class Rectangle {
      // member variables
      protected internal double length;
      protected internal double width;
      
      double GetArea() {
         return length * width;
      }
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }// end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

When the above code is compiled and executed, it produces the following result −

Length: 4.5
Width: 3.5
Area: 15.75

In the preceding example, notice that the member function GetArea() is not declared with any access specifier. Then what would be the default access specifier of a class member if we don't mention any? It is private.

Encapsulation Using Private Fields and Methods

You can implement encapsulation by using the private fields and methods, which restrict direct access to the fields and can control data through using the public properties or methods.

Example

In the following example, we are using private fields to encapsulate data and public methods (SetName and GetName) to control access and modification of the name field:

using System;

class Person {
    // Private field
	private string name;

    // Public method - Setting the name
    public void SetName(string newName) {
        if (!string.IsNullOrEmpty(newName)) {
            name = newName;
        } else {
            Console.WriteLine("Name cannot be empty.");
        }
    }

    // Public method - Getting the name
    public string GetName() {
        return name;
    }
}

class Program {
    static void Main() {
        Person person = new Person();
        person.SetName("Sudhir Sharma");
        Console.WriteLine("Person's Name: " + person.GetName());
    }
}

When the above code is compiled and executed, it produces the following result −

Person's Name: Sudhir Sharma

Encapsulation Using Properties

There is another way to implement encapsulation by using the properties (set and get).

Example

In the following example, we are using a private field to store the salary and a public property (Salary) with validation logic to control how the salary is set:

using System;

class Employee {
    private double salary;  // Private field

    // Public property with validation logic
    public double Salary {
        get { return salary; }
        set {
            if (value >= 3000) {
                salary = value;
            } else {
                Console.WriteLine("Salary must be at least 3000.");
            }
        }
    }
}

class Program {
    static void Main() {
        Employee emp = new Employee();
        emp.Salary = 5000;  // Valid salary
        Console.WriteLine("Employee Salary: " + emp.Salary);

        emp.Salary = 2000;  // Invalid salary
        Console.WriteLine("Updated Salary: " + emp.Salary);
    }
}

When the above code is compiled and executed, it produces the following result −

Employee Salary: 5000
Salary must be at least 3000.
Updated Salary: 5000
Print Page
Previous
Next
Advertisements