C# Method Overloading vs Overriding: The Difference

Two methods with the same name? That's overloading. A derived class changing a base method? That's overriding.

Imagine you're building a calculator. You want a method called Add that can work with two integers, two decimals, or even three numbers. You don't want to remember AddInts, AddDecimals, AddThree — you just want one name: Add.

Now imagine you're building a payment system. You have a base PaymentProcessor class, and you want a PayPalProcessor that processes payments differently but still follows the same contract.

Overloading and overriding are two of the most important tools in object-oriented programming. They both involve methods with the same name, but they solve fundamentally different problems. Understanding the difference — and when to use each — is essential for writing clean, maintainable C# code.

What Is It?

The Simple Explanation

Overloading — multiple methods in the same class that share the same name but have different parameters. The compiler decides which one to call based on the arguments you provide.

Overriding — a derived class redefines a method from its base class using the override keyword. The runtime decides which implementation to execute based on the actual object type.

The Technical Definition

Why Does It Exist?

Overloading — The Problem

Without overloading, you'd need separate method names for every variation:

int AddInts(int a, int b) { ... }
double AddDoubles(double a, double b) { ... }
int AddThreeInts(int a, int b, int c) { ... }
decimal AddDecimals(decimal a, decimal b) { ... }

This is hard to remember, hard to read, and makes your API feel clumsy. You want one intuitive name that works naturally with different types and arities.

Overloading — The Solution

Overloading lets you use a single, meaningful name for a family of related operations. The compiler figures out which one to use based on the arguments at compile time.

Overriding — The Problem

Imagine you have a base class with a method that does something useful, but you need slightly different behavior in a derived class. Without overriding, you'd have to hide the base method with new (which breaks polymorphism) or use completely different method names (which defeats inheritance).

Overriding — The Solution

Overriding allows a derived class to replace the base implementation while keeping the same method signature. This enables runtime polymorphism — you can write code that works with the base type, but the derived type's behavior is used at runtime.

Big Picture

How It Works

Overloading — Compile-Time Resolution

Overriding — Runtime Resolution

public virtual string GetGreeting() => "Hello";

public override string GetGreeting() => "G'day";

Base obj = new Derived();
obj.GetGreeting();

Simple Example

Overloading

public class Calculator
{
    // Overload 1: two ints
    public int Add(int a, int b) => a + b;

    // Overload 2: two doubles
    public double Add(double a, double b) => a + b;

    // Overload 3: three ints
    public int Add(int a, int b, int c) => a + b + c;

    // Overload 4: two decimals
    public decimal Add(decimal a, decimal b) => a + b;
}

// Usage
var calc = new Calculator();
Console.WriteLine(calc.Add(5, 10));        // 15 (int, int)      → overload 1
Console.WriteLine(calc.Add(5.5, 2.3));     // 7.8 (double, double) → overload 2
Console.WriteLine(calc.Add(1, 2, 3));      // 6 (int, int, int)   → overload 3
Console.WriteLine(calc.Add(5.99m, 2.01m)); // 8.00 (decimal, decimal) → overload 4

Code → Meaning → Result

• Four methods all named Add — each with a different signature.
• The compiler chooses the correct one based on the argument types and count.
• This makes the API intuitive — you just call Add with whatever numbers you have.

Overriding

public class Animal
{
    public virtual string Speak() => "Some animal sound";
}

public class Dog : Animal
{
    public override string Speak() => "Woof!";
}

public class Cat : Animal
{
    public override string Speak() => "Meow!";
}

// Usage
Animal a1 = new Animal();
Animal a2 = new Dog();
Animal a3 = new Cat();

Console.WriteLine(a1.Speak());  // "Some animal sound"
Console.WriteLine(a2.Speak());  // "Woof!"   ← runtime decides!
Console.WriteLine(a3.Speak());  // "Meow!"   ← runtime decides!

Code → Meaning → Result

• Animal defines a virtual method — a placeholder.
• Dog and Cat override it with their own implementation.
• Even though all variables are typed as Animal, the runtime calls the correct overridden method based on the actual object type.

Real-World Example

Imagine an e-commerce system with different payment processors. Overloading and overriding work together to make the system flexible and clean.

// ─── Base class with a virtual method ───
public abstract class PaymentProcessor
{
    public abstract bool ProcessPayment(decimal amount);

    // Overloaded helper methods
    public bool ProcessPayment(decimal amount, string currency)
    {
        // Convert currency if needed, then call the main overload
        return ProcessPayment(ConvertToBaseCurrency(amount, currency));
    }

    public bool ProcessPayment(decimal amount, string currency, string description)
    {
        LogPayment(description);
        return ProcessPayment(amount, currency);
    }

    protected virtual void LogPayment(string description)
    {
        Console.WriteLine($"Log: {description}");
    }

    private decimal ConvertToBaseCurrency(decimal amount, string currency) { ... }
}

// ─── Derived classes override the core method ───
public class StripeProcessor : PaymentProcessor
{
    public override bool ProcessPayment(decimal amount)
    {
        Console.WriteLine($"Stripe: processing {amount:C}");
        // Stripe API call...
        return true;
    }
}

public class PayPalProcessor : PaymentProcessor
{
    public override bool ProcessPayment(decimal amount)
    {
        Console.WriteLine($"PayPal: processing {amount:C}");
        // PayPal API call...
        return true;
    }

    // Override logging too
    protected override void LogPayment(string description)
    {
        Console.WriteLine($"PayPal Log: {description.ToUpperInvariant()}");
    }
}

// ─── Usage ───
var processors = new List<PaymentProcessor>
{
    new StripeProcessor(),
    new PayPalProcessor()
};

foreach (var processor in processors)
{
    // Even though we only know about PaymentProcessor,
    // each processor uses its own implementation!
    processor.ProcessPayment(99.99m, "USD", "Order #1234");
}

What's happening here?

• Overriding — each payment processor has its own ProcessPayment implementation. The system works with PaymentProcessor references, but the correct processor is used at runtime.
• Overloading — the ProcessPayment method has multiple overloads (amount only, amount+currency, amount+currency+description). This gives callers flexibility while keeping the name consistent.
• Together — overloading provides convenience at the call site, while overriding enables polymorphic behavior in the inheritance hierarchy.

Analogy

Under the Hood

Common Confusion

1. Overloading vs Overriding — The Names Are Similar, the Behaviors Are Not

This is the single biggest source of confusion. Both involve methods with the same name, but they are fundamentally different:

2. Hiding (new) vs Overriding (override)

Using new in a derived class hides the base method — it doesn't override it. When you call the method on a base-type reference, the base implementation runs, not the derived one. This breaks polymorphism and is almost always what you don't want in inheritance hierarchies.

public class Base
{
    public virtual void M() => Console.WriteLine("Base.M");
}
public class DerivedNew : Base
{
    public new void M() => Console.WriteLine("DerivedNew.M"); // hides!
}
public class DerivedOverride : Base
{
    public override void M() => Console.WriteLine("DerivedOverride.M");
}

Base b1 = new DerivedNew();
Base b2 = new DerivedOverride();
b1.M();  // "Base.M"      ← new doesn't override
b2.M();  // "DerivedOverride.M"  ← override works

3. Overloading and Return Types

Return type alone does NOT distinguish overloads. You cannot have two methods with the same name and same parameters but different return types — the compiler can't know which one to call.

//  Does NOT compile
public int GetValue() => 42;
public string GetValue() => "42";  // Compiler error!

Common Mistakes

Mistake 1 — Forgetting override keyword

Wrong — this hides the method instead of overriding it:

public class Dog : Animal
{
    public string Speak() => "Woof!";  // Hides, doesn't override!
}

Correct — use override to get polymorphic behavior:

public class Dog : Animal
{
    public override string Speak() => "Woof!";
}

Mistake 2 — Overloading with ambiguous parameters

Creating overloads that can cause ambiguity:

public void M(int a, double b) { }
public void M(double a, int b) { }
// M(1, 2) → ambiguous! Compiler error.

Design overloads where the compiler can unambiguously choose based on argument types.

Mistake 3 — Forgetting to call base when needed

When overriding, sometimes you need the base behavior to run in addition to your new behavior. Forgetting base.Method() can break important setup logic.

public override void Dispose()
{
    //  Missing: base.Dispose();
    // Now base resources are never cleaned up!
}

When Should I Use It?

Use overloading when:

• You need the same logical operation to work with different types or different numbers of parameters
• You want to provide convenience to callers (e.g., Console.WriteLine has 19 overloads so you can print almost anything)
• You're designing a fluent API or a helper class
• You want to provide default values via overloads (e.g., one overload with 2 params, another with 3 where the third has a default)

Use overriding when:

• You have a base class with behavior that should be customizable or replaceable in derived classes
• You're implementing a template method pattern where base class calls virtual methods
• You need runtime polymorphism — working with base-type references but getting derived behavior
• You're building a framework or library where users can extend your classes
• You need to provide a different implementation of ToString(), Equals(), or GetHashCode() in your custom type

When to avoid over-using:

• Too many overloads can make the API confusing — use defaults and optional parameters where appropriate
• Overriding everything by default can make design fragile — prefer sealed for classes/methods that shouldn't be extended
• If you're not using inheritance, you don't need overriding — composition over inheritance is often a better design

Mental Model

Key Takeaway

Check Your Understanding

You've seen how overloading and overriding work, how they differ, and when to use each. Let's see if you can apply these concepts.

public class Shape
{
    public virtual void Draw() => Console.WriteLine("Shape");
}
public class Circle : Shape
{
    public override void Draw() => Console.WriteLine("Circle");
}
public class Square : Shape
{
    public new void Draw() => Console.WriteLine("Square");
}

Shape s1 = new Circle();
Shape s2 = new Square();
s1.Draw();
s2.Draw();

You now have a solid mental model of overloading and overriding — you can distinguish them, use them correctly, and explain why they exist!