C# Abstraction : A Tutorial

Abstraction is one of the four main pillars of Object-Oriented Programming (OOP) in C#.

It is the process of hiding implementation details while exposing only the necessary functionalities to the user. Abstraction helps in reducing complexity and increasing code maintainability.

C# provides abstraction through:

1. Abstract Classes
2. Interfaces

This tutorial covers:

• What is Abstraction?
• Implementing Abstraction Using Abstract Classes
• Implementing Abstraction Using Interfaces
• Difference Between Abstract Classes and Interfaces
• Best Practices for Abstraction

1. What is Abstraction?

Abstraction allows hiding the details of implementation and exposing only the essential features. It helps in:

• Encapsulating complex logic
• Reducing dependencies
• Providing a clear and minimal interface

For example, when using a car, the driver only needs to know how to start the engine and accelerate, but not how the engine works internally.

2. Implementing Abstraction Using Abstract Classes

An abstract class cannot be instantiated and may contain both abstract methods (without implementation) and concrete methods (with implementation).

Example: Abstract Class with Abstract Method

abstract class Vehicle
{
    public abstract void Start(); // Abstract method (must be implemented)

    public void Stop() // Concrete method (already implemented)
    {
        Console.WriteLine("Vehicle stopped.");
    }
}

class Car : Vehicle
{
    public override void Start()
    {
        Console.WriteLine("Car engine started.");
    }
}

class Program
{
    static void Main()
    {
        Vehicle myCar = new Car();
        myCar.Start(); // Output: Car engine started.
        myCar.Stop();  // Output: Vehicle stopped.
    }
}

Explanation:

• The Vehicle class is abstract and cannot be instantiated.
• The Start() method is abstract and must be overridden in derived classes.
• The Stop() method is concrete and can be used without overriding.

3. Implementing Abstraction Using Interfaces

An interface is a fully abstract class where all methods are abstract by default. It defines a contract that must be followed by any class that implements it.

Example: Implementing an Interface

interface IShape
{
    void Draw(); // No implementation, only declaration
}

class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

class Rectangle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

class Program
{
    static void Main()
    {
        IShape shape1 = new Circle();
        IShape shape2 = new Rectangle();

        shape1.Draw(); // Output: Drawing a circle.
        shape2.Draw(); // Output: Drawing a rectangle.
    }
}

Explanation:

• The IShape interface defines a method without implementation.
• The Circle and Rectangle classes implement the interface and provide their own versions of Draw().

4. Difference Between Abstract Classes and Interfaces

Example: Combining Abstract Class and Interface

interface IEngine
{
    void StartEngine();
}

abstract class Vehicle
{
    public abstract void Drive();
}

class Car : Vehicle, IEngine
{
    public override void Drive()
    {
        Console.WriteLine("Car is driving.");
    }

    public void StartEngine()
    {
        Console.WriteLine("Car engine started.");
    }
}

class Program
{
    static void Main()
    {
        Car myCar = new Car();
        myCar.StartEngine(); // Interface method
        myCar.Drive();       // Abstract class method
    }
}

• Car inherits from Vehicle (abstract class) and implements IEngine (interface).
• This shows how to use both abstraction techniques together.

5. Best Practices for Abstraction

Use Abstract Classes When:

• You have common behavior that derived classes should inherit.
• You need fields, constructors, or implemented methods.
• You want to share code among related classes.

Use Interfaces When:

• You need a contract without shared code.
• You need multiple inheritance (since a class can implement multiple interfaces).
• You are working with dependency injection.

Follow the Single Responsibility Principle

• Ensure each class has one responsibility.

interface IPrinter
{
    void Print();
}

interface IScanner
{
    void Scan();
}

class MultiFunctionPrinter : IPrinter, IScanner
{
    public void Print() { Console.WriteLine("Printing document."); }
    public void Scan() { Console.WriteLine("Scanning document."); }
}

• Interfaces separate responsibilities, making the code more maintainable.

Avoid Overcomplicating with Too Many Abstract Methods

• Abstract classes should not be used if a base class already provides enough functionality.

abstract class Shape
{
    public abstract double GetArea(); // Keep abstraction meaningful
}

• Use abstraction only when necessary.

Use Meaningful Names for Abstract Methods

• Avoid generic method names like DoSomething().

abstract class Animal
{
    public abstract void MakeSound(); // Clear and descriptive
}

• Clear method names improve code readability.

Conclusion

• Abstraction hides implementation details while exposing only the necessary functionalities.
• Abstract classes allow both abstract and concrete methods.
• Interfaces define a contract that must be implemented by derived classes.
• Use abstract classes when common behavior is needed and interfaces when multiple behaviors must be enforced.
• Following best practices ensures maintainable and scalable code.