Interfaces vs Abstract Classes

🚀 C# Tip — Interfaces vs Abstract Classes (When to Use Each)

Choosing between an interface and an abstract class is not a syntax decision. It’s an architecture decision.

Both exist to model contracts, but they solve different problems.

🧠 The Core Difference

• Interface → What a class can do
• Abstract class → What a class is

That distinction alone solves most debates.

🧩 Interfaces — Contracts & Capabilities

public interface IPaymentGateway
{
    Task ChargeAsync(decimal amount);
}

✅ When interfaces shine

• Multiple inheritance of behavior
• Dependency Injection
• Plugin/extensibility models
• Clean Architecture boundaries
• Unit testing & mocking

👍 Strengths

• A class can implement many interfaces
• No implementation inheritance
• Clear separation of concerns
• Ideal for cross-cutting capabilities

🧱 Abstract Classes — Shared Identity & Base Behavior

public abstract class PaymentGateway
{
    protected void Log(string message) { }

    public abstract Task ChargeAsync(decimal amount);
}

✅ When abstract classes shine

• Shared implementation is required
• Protected helpers are needed
• Strong “is-a” relationship
• Template Method pattern

👍 Strengths

• Can hold state
• Can provide base behavior
• Can evolve without breaking all implementers

⚠️ Key Trade-Offs (That Matter in Practice)

❌ Interfaces

• No shared state
• Breaking changes hurt more
• Can lead to “interface explosion” if abused

❌ Abstract Classes

• Single inheritance only
• Tighter coupling
• Harder to refactor later
• Less flexible in large systems

🧠 Modern C# Changes (Important!)

Default interface methods (C# 8+)

public interface ILogger
{
    void Log(string msg);

    void Info(string msg) => Log($"INFO: {msg}");
}

✔️ Helps evolve interfaces
❌ Does not replace abstract classes
❌ No state, no fields

⚖️ Comparison at a Glance

🏗️ Real-World Rule of Thumb

• Public API / boundaries → Interface
• Domain base type → Abstract class
• DI & test seams → Interface
• Shared internal behavior → Abstract class

Start with an interface.
Move to an abstract class only when sharing behavior becomes unavoidable.

🎯 Final Takeaway

Interfaces give you flexibility.
Abstract classes give you reuse.

Choose based on coupling vs freedom, not convenience.

Bad abstractions are worse than no abstractions.

#csharp #dotnet #oop #architecture #cleancode #softwareengineering