Interfaces Vs Abstract Classes In C# Complete Guide

Interfaces vs. Abstract Classes in C#: Complete Examples for Beginners

1. Overview

In C#, interfaces and abstract classes are both used to achieve abstraction, a fundamental concept in object-oriented programming. However, they serve different purposes and are used in distinct scenarios.

• Interfaces: Define a contract that other classes must implement. They specify what a class can do, not how it does it.
• Abstract Classes: Provide a common base class with some implementations shared by derived classes. They can define both abstract methods (without implementation) and concrete methods (with implementation).

2. Key Differences

| Feature | Interfaces | Abstract Classes | |--------------------------------|-------------------------------------------|--------------------------------------------------------------------------| | Multiple Inheritance | Yes (a class can implement multiple interfaces) | No (a class can inherit only one abstract class) | | Implementation Details | No implementation (except default interfaces in C# 8+) | Can contain both abstract methods and concrete methods | | Constructor | No constructors | Can have constructors | | Access Modifiers | Members are always public (C# 8 onwards, members default to public) | Members can have various access modifiers (public, protected, etc.) | | Usage | Define capabilities or APIs | Provide a common base implementation and shared code | | Performance | Slightly performance overhead due to method dispatch | Can be slightly more efficient as it can contain implementation |

3. Practical Examples

Let's implement both interfaces and abstract classes to illustrate their usage.

3.1. Using Interfaces

Suppose we want to create a system for different types of vehicles, and all vehicles must know how to Start() and Stop().

using System;

// Define the IVehicle interface
public interface IVehicle
{
    // Methods that must be implemented by any class that implements IVehicle
    void Start();
    void Stop();
}

// Implement the interface in a Car class
public class Car : IVehicle
{
    public void Start()
    {
        Console.WriteLine("Car is starting.");
    }

    public void Stop()
    {
        Console.WriteLine("Car is stopping.");
    }
}

// Implement the interface in a Motorcycle class
public class Motorcycle : IVehicle
{
    public void Start()
    {
        Console.WriteLine("Motorcycle is starting.");
    }

    public void Stop()
    {
        Console.WriteLine("Motorcycle is stopping.");
    }
}

class Program
{
    static void Main()
    {
        IVehicle myCar = new Car();
        IVehicle myMotorcycle = new Motorcycle();

        myCar.Start(); // Output: Car is starting.
        myCar.Stop();  // Output: Car is stopping.

        myMotorcycle.Start(); // Output: Motorcycle is starting.
        myMotorcycle.Stop();  // Output: Motorcycle is stopping.
    }
}

Explanation:

• IVehicle Interface: Defines the Start() and Stop() methods that any vehicle must implement.
• Car and Motorcycle Classes: Both implement the IVehicle interface, providing their specific implementations of Start() and Stop().
• Polymorphism: We can use the IVehicle interface type to declare variables and pass different vehicle types, demonstrating polymorphism.

3.2. Using Abstract Classes

Now, let's create a system where we have different types of bank accounts, and all accounts must calculate Interest(), but some shared functionality can be provided.

using System;

// Define the BankAccount abstract class
public abstract class BankAccount
{
    // Properties
    public string AccountHolderName { get; set; }
    public double Balance { get; protected set; }

    // Constructor
    public BankAccount(string accountHolderName, double initialBalance)
    {
        AccountHolderName = accountHolderName;
        Balance = initialBalance;
    }

    // Abstract method: Must be implemented by derived classes
    public abstract double CalculateInterest();

    // Concrete method: Provides common functionality
    public void Deposit(double amount)
    {
        Balance += amount;
        Console.WriteLine($"Deposited ${amount}. New balance: ${Balance}.");
    }

    public void Withdraw(double amount)
    {
        if (amount <= Balance)
        {
            Balance -= amount;
            Console.WriteLine($"Withdrew ${amount}. New balance: ${Balance}.");
        }
        else
        {
            Console.WriteLine("Insufficient funds.");
        }
    }
}

// Implement the abstract class in a SavingsAccount class
public class SavingsAccount : BankAccount
{
    public double InterestRate { get; set; }

    public SavingsAccount(string accountHolderName, double initialBalance, double interestRate) 
        : base(accountHolderName, initialBalance)
    {
        InterestRate = interestRate;
    }

    public override double CalculateInterest()
    {
        return Balance * InterestRate;
    }
}

// Implement the abstract class in a CheckingAccount class
public class CheckingAccount : BankAccount
{
    public double OverdraftLimit { get; set; }

    public CheckingAccount(string accountHolderName, double initialBalance, double overdraftLimit) 
        : base(accountHolderName, initialBalance)
    {
        OverdraftLimit = overdraftLimit;
    }

    public override double CalculateInterest()
    {
        // Checking accounts might not earn interest
        return 0;
    }

    public new void Withdraw(double amount)
    {
        double totalAvailable = Balance + OverdraftLimit;
        if (amount <= totalAvailable)
        {
            Balance -= amount;
            Console.WriteLine($"Withdrew ${amount}. New balance: ${Balance}.");
        }
        else
        {
            Console.WriteLine("Insufficient funds.");
        }
    }
}

class Program
{
    static void Main()
    {
        SavingsAccount savings = new SavingsAccount("Alice", 1000, 0.05);
        CheckingAccount checking = new CheckingAccount("Bob", 500, 200);

        savings.Deposit(200);
        savings.Withdraw(50);
        double savingsInterest = savings.CalculateInterest();
        Console.WriteLine($"Savings account interest: ${savingsInterest}.");

        checking.Withdraw(600); // Overdraft within limit
        checking.Withdraw(900); // Overdraft exceeds limit
        double checkingInterest = checking.CalculateInterest();
        Console.WriteLine($"Checking account interest: ${checkingInterest}.");
    }
}

Explanation:

• BankAccount Abstract Class: Provides common properties (AccountHolderName, Balance) and methods (Deposit(), Withdraw()). It declares an abstract method CalculateInterest() that must be implemented by derived classes.
• SavingsAccount and CheckingAccount Classes: Derive from BankAccount and provide their specific implementations of CalculateInterest(). The CheckingAccount also overrides the Withdraw() method to include overdraft functionality.
• Shared Functionality: Methods like Deposit() and Withdraw() are shared across different account types, demonstrating code reuse.
• Polymorphism: We can use the BankAccount type to declare variables and pass different account types.

4. When to Use Interfaces vs. Abstract Classes

• Use Interfaces When:

  • You need to define a contract for multiple, unrelated classes.
  • You want to promote loose coupling and flexibility.
  • Multiple classes need to implement the same functionality independently.
  • You need to update the contract without breaking existing implementations (e.g., in different assemblies).

• Use Abstract Classes When:

  • You need to share code among related classes.
  • You want to provide a common base class with some default implementations.
  • You need to control the creation of objects (e.g., using a factory pattern).
  • You want to define a template for subclasses with some shared behavior.

5. Key Points to Remember

• Interfaces are ideal for defining capabilities or APIs that can be implemented by any class, regardless of where it fits within the class hierarchy.
• Abstract Classes are useful when you have a common base class with shared code and specific methods that must be implemented by derived classes.
• C# 8+ introduced default interface implementations, allowing interfaces to have method bodies, blurring the line slightly between interfaces and abstract classes.
• Use composition to combine interfaces and abstract classes for even more flexibility and reusability.

6. Additional Resources

• Microsoft Documentation on Interfaces
• Microsoft Documentation on Abstract Classes
• C# Abstract Class vs. Interface - TutorialsTeacher

By understanding when and how to use interfaces and abstract classes, you can write more flexible, maintainable, and scalable C# code.