Abstraction vs Encapsulation in C#: Difference between abstraction and encapsulation

Last updated on May 16th, 2024 at 02:05 am

In C#, the key difference between abstraction and encapsulation is that encapsulation wraps data and methods into a single unit called class, whereas abstraction hides implementation details and just shows users the functionality.

What is the difference between abstraction and encapsulation in C# programming?

Abstraction: Abstraction is the concept of hiding the complex implementation details and showing only the necessary information to the outside world. It defines what an object should do without exposing how it achieves its purpose. 

• It allows you to define a blueprint for a class without specifying the implementation details.
• Abstraction can be achieve through abstract classes and interfaces in C#.

Code Example of Abstraction in C#:

// Abstract class
public abstract class Shape
{
    // Abstract method
    public abstract void Draw();
}

// Concrete class implementing the abstract class
public class Circle : Shape
{
    // Implementing the Draw method
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

Abstraction Example: Think of the outer layout of a Phone – The display screen is an important feature that represents the necessary functionality without exposing the internal mechanics.

Encapsulation: Encapsulation is the concept of bundling the data (variables) and methods (functions) that operate on the data into a single unit (class).

•  It helps control access to data by hiding an object’s internal state and exposing only the necessary functionalities.
• Encapsulation can be achieve through access modifiers like private, protected, and public in C#.
• It wraps data and methods into a single unit (class), ensuring that clients interact with public properties rather than directly accessing private data. 

Code example of encapsulation in C#:

public class Employee
{
    // Private fields
    private string name;
    private int age;

    // Public property for Name
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    // Public property for Age
    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 18)
            {
                age = value;
            }
            else
            {
                Console.WriteLine("Age must be 18 or older.");
            }
        }
    }
}

Code Explanation:

• Private fields: The name and age fields are declared as private, ensuring they cannot be accessed directly from outside the Employee class.
• Public properties: Instead of separate getter and setter methods, properties are used to encapsulate access to the private fields. This provides a cleaner syntax for getting and setting the values of name and age.
• Name property: The Name property encapsulates access to the name field. It has both a getter and a setter, allowing external code to get and set the value of name.
• Age property: The Age property encapsulates access to the age field. It also has both a getter and a setter. The setter includes logic to ensure that the new age is 18 or older before setting the value. If the age is not valid, it outputs an error message to the console.

Example: Imagine the inner implementation details of a Phone – the complex connections between display screens using circuits. Encapsulation shields these details from external users.

In short, Abstraction focuses on hiding the implementation details, while encapsulation focuses on bundling data and methods together and controlling access to the data. Both

concepts are important in object-oriented programming and help in creating more maintainable and scalable code

Definition of Abstraction in C#

Abstraction is the technique of exposing only the essential details while hiding the rest. In simple words, data abstraction is defined in C# as the process of reducing an object to its core and exposing only the relevant details of the object to the users.

“Abstraction is the process of working with ideas rather than putting them into action.
The implementation complexities are hidden from the users in abstraction.“

How to Achieve Abstraction in C#?

• In C#, we can use  Abstract classes and interfaces to achieve Abstraction.
  Complete abstraction is possible with interfaces that allow you to entirely encapsulate the implementation.
• Abstract classes allow partial or complete abstraction because they might have concrete methods with implementation, resulting in partial abstraction.

Encapsulation in C#?

Encapsulation is a fundamental concept in object-oriented programming that involves bundling data (variables) and methods (functions) that operate on the data into a single unit (class) and controlling access to that data. 

Encapsulation allows an object’s internal state to be hidden from the outside world, with access to the data restricted to designated methods within the class. 

It promotes data hiding by encapsulating related functionalities within a class and providing a well-defined interface for interacting with the object.

Key points about encapsulation

Encapsulation in C# is a fundamental object-oriented programming (OOP) concept that refers to hiding an object’s implementation details from other parts of the program. It involves bundling the data (fields, properties) and behavior (methods) that operate on that data within a single unit called a class.

The class exposes a set of well-defined public interfaces (methods, properties, events) that other parts of the program can use to interact with the object while keeping the implementation details hidden. It provides several benefits, including:

Read my previous article to learn more about Encapsulation in C#.

How to Achieve encapsulation in C#?

In C#, encapsulation can be achieve using access modifiers such as private, public, protected, and internal to control the visibility of the members of a class.

By default, the access level of a member is private, meaning that it can only be accessed within the same class. On the other hand, Public members can be accessed from any part of the program.

In C#, encapsulation can be performed by:

• Declaring class variables as private.
• Providing a public method or a getter and setter property that can be used to modify and read the values of private variables.

“Encapsulation refers to a situation in which a class’s variables or data are hidden from other classes and can only be accessed through member functions/properties of the class in which they are specified.“

Let’s take a look at the code to see how encapsulation is implemented:

As you can see in the above code, we have created a class Employee with private variables firstName and lastName. 

Then, we created a public property fullName to get the value from the private variables. Because private fields cannot be accessed outside of the class, any class wishing to get the employee name (private field value) must use this public property.

It allows us to quickly get the employee`s full name without worrying about how the Employee class handles first and last names internally.

Advantages of Encapsulation:

Here are some advantages of encapsulation in C#:

1. Data Hiding:

Encapsulation allows you to hide the internal state of an object by making data members private and providing public methods to access and modify that data. It helps prevent unauthorized access and manipulation of data, enhancing security and integrity.

2. Modularity:

Encapsulation promotes modularity by bundling data and methods together within a class. This makes managing and maintaining code easier, as related functionalities are grouped together, improving code readability.

3. Code Reusability:

Encapsulation facilitates code reusability by encapsulating common functionalities within a class. Other parts of the program can then interact with the class through its public interface, allowing for easy code reuse without duplicating it.

4. Flexibility and Maintenance:

Encapsulation enhances flexibility and maintenance of code by isolating the implementation details of a class. Changes to the internal implementation can be made without affecting other parts of the program, reducing the risk of unintended side effects and making it easier to update and maintain the codebase.

Refer this link to learn more about the Encapsulation in C#

Difference between Abstraction and Encapsulation in C#

Abstraction example

The following is a code snippet for data abstraction:

using System;
namespace AbstractionExample
{
    /* C# program written to calculate the area
      of a Circle and square using the concept of
      data abstraction */

    // Abstarct class
    abstract class Shape
    {
        // Abstract method
        public abstract double area();
    }

    // Child class( Circle) inheriting
   // the parent (Shape) class.
    class Circle : Shape
    {
        // private data member
        private double radius;

        // Constructor
        public Circle(double radius)
        {
            this.radius = radius;
        }

        // overriding of the abstract method using the override keyword.
        public override double area()
        {
            return (3.14 * radius * radius);
        }
    }
    class Square : Shape
    {
        private double side;
        public Square(double side)
        {
            this.side = side;
        }    
        public override double area()
        {
            return (side * side);
        }
    }
   
    class Program
    {
        static void Main(string[] args)
        {
            // Creating reference of Parent (Shape) class
            // which refer to child (Circle & Square) classes instance.
            Shape shape = new Circle(5.0);
            Console.WriteLine($"Area of Circle = {shape.area()}");
                  shape = new Square(5.5);
            Console.WriteLine($"Area of Square = {shape.area()}");
            Console.ReadLine();

            //Output:
            //Area of Circle = 78.5
            //Area of Square = 30.25
        }
    }
}

The Base class only exposes the method definition, input parameters, and return type of the abstract method. However, it does not expose the method`s implementation details, such as how it is implemented differently in different child classes; this is referred to as abstraction.

FAQs:

Conclusion

In this post, we have gone through the relevance of the OOPs concept and learned what abstraction and encapsulation mean. We went over several abstraction and encapsulation examples. We also discussed the advantages of abstraction and encapsulation. Finally, we looked at the difference between abstraction and encapsulation.

Thank you for reading the blog; if you enjoyed it, please like, comment, and share it with others. 

References: C# | Abstraction

Articles to Check Out:

• C# Abstract class Vs Interface
• C# Encapsulation: Everything You Need to Know
• WCF vs WEB API
• Top 50 C# Interview Questions And Answers For Freshers And Experienced
• Collections in C# .NET
• ASP.NET Core Middleware With Examples
• C# Struct vs Class
• C# StreamReader & StreamWriter
• Boxing and Unboxing – C# Programming
• SOLID Design Principles in C#: A Complete Example
• Singleton Design Pattern in C#: A Beginner’s Guide with Examples
• C# Dependency Injection

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• Difference Between Array And ArrayList In C#: Choosing the Right Collection - May 28, 2024
• C# Program to Capitalize the First Character of Each Word in a String - February 21, 2024
• C# Program to Find the Longest Word in a String - February 19, 2024