A Complete Guide - Interfaces vs Abstract Classes in C#

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

• You May Like This Related .NET Topic

  📥 Download Code ▶️ Watch Online 📖 Read Description