Interface vs abstract class decision in C Sharp (C#) - Performance Comparison

Time Complexity: Interface vs abstract class decision

O(n)

Understanding Time Complexity

When deciding between an interface and an abstract class, it's helpful to understand how their use affects program execution time.

We want to see how the choice impacts the speed of method calls and object behavior.

Scenario Under Consideration

Analyze the time complexity of calling methods via interface and abstract class references.

public interface IWorker
{
    void Work();
}

public abstract class WorkerBase
{
    public abstract void Work();
}

public class Employee : WorkerBase, IWorker
{
    public override void Work() { /* work implementation */ }
}

// Usage
Employee emp = new Employee();
IWorker iworker = emp;
WorkerBase abworker = emp;
iworker.Work();
abworker.Work();
    

This code shows method calls through interface and abstract class references to the same object.

Identify Repeating Operations

Identify the method calls that happen repeatedly in a program using these types.

• Primary operation: Calling the Work() method via interface or abstract class reference.
• How many times: Depends on program usage; could be many times in loops or event handlers.

How Execution Grows With Input

Each method call through interface or abstract class reference takes roughly the same time regardless of input size.

Input Size (n)	Approx. Operations
10	10 method calls
100	100 method calls
1000	1000 method calls

Pattern observation: The time grows linearly with the number of calls, but each call's overhead is constant whether using interface or abstract class.

Final Time Complexity

Time Complexity: O(n)

This means the total time grows linearly with how many times you call the method, regardless of using interface or abstract class.

Common Mistake

[X] Wrong: "Using an interface is always slower than an abstract class because of extra overhead."

[OK] Correct: Both interface and abstract class method calls use similar mechanisms under the hood, so their call times are very close and usually not a deciding factor.

Interview Connect

Understanding that interface and abstract class calls have similar time costs helps you focus on design choices rather than performance worries, showing good judgment in interviews.

Self-Check

"What if the method called was virtual in the abstract class but not part of an interface? How would that affect the time complexity?"