Understanding the Difference Between Overriding and Overloading in C#

Last updated on December 20th, 2023 at 06:19 pm

Overriding and Overloading the two important concepts of Polymorphism. 

Overloading in C# is known as Static Polymorphism or Compile time Polymorphism. In Overloading we can create methods with the same name but different parameters within the same class.

On the other hand, Overriding is known as dynamic Polymorphism or Runtime Polymorphism which allows us to provide different implementation of a method in Inherited Classes.

In this article, we will learn the differences between overriding and overloading in C# with practical code examples.

What Are Overriding and Overloading?

Before we jump into the nitty-gritty details, let’s clarify what overriding and overloading actually mean in C#:

What Is Method Overloading In C#?

Overloading is a technique that allows you to define multiple methods in the same class with the same name but different parameters. 

These parameters might be of different types, or they may have a different number of parameters. When you call an overloaded method, the compiler decides which one to execute based on the method’s parameters.

Overloading is also known as compile-time or static polymorphism because each of the different overloaded methods is resolved during the compilation of the application.

Example: Method Overloading:

In this code, we have a Calculator class with three overloaded Add methods, each methods accepting different data types.

using System;

namespace ExampleMethodOverloading
{
    class Calculator
    {
        // Overloaded method to add two integers
        public int Add(int a, int b)
        {
            return a + b;
        }

        // Overloaded method to add two doubles
        public double Add(double a, double b)
        {
            return a + b;
        }

        // Overloaded method to add three floats
        public float Add(float a, float b, float c)
        {
            return a + b + c;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();

            // Using the first overloaded method (integers)
            int result1 = calculator.Add(5, 10);
            Console.WriteLine("Adding two integers: " + result1);

            // Using the second overloaded method (doubles)
            double result2 = calculator.Add(5.5, 10.5);
            Console.WriteLine("Adding two doubles: " + result2);

            // Using the third overloaded method (floats)
            float result3 = calculator.Add(10.5f, 20.5f, 30.5f);
            Console.WriteLine("Adding three floats: " + result3);

            Console.ReadLine();
        }
    }
}

Output:

Adding two integers: 15
Adding two doubles: 16
Adding three floats: 61.5

Key Points About Method Overloading in C#

• Method overloading allows you to create multiple methods within the same class with the same name, but each method can perform a different task. 
• Overloaded methods must have different parameter lists. You can achieve overloading by changing the number of parameters, using different data types, or altering the order of parameters. 
• Method overloading is resolved at compile time, also known as early binding. The compiler determines which method to call based on the number and types of arguments provided when the method is invoked.
• Method overloading does not take into account the return type of the method. Two methods with the same name and the same parameter list but different return types are not considered overloaded, and they would cause a compile-time error.

What is method overriding?

Overriding is the ability to create a method in the derived class with the same signature as a method in the base class.

This means that when you override a method in a derived class, it must have the same method signature as the one in the base class. This ensures that you’re providing a specialized implementation while maintaining method compatibility.

Overriding is often referred to as runtime or dynamic polymorphism because the calling object is only known at runtime based on the specific method implementation.

Example: Method Overriding:

Let’s understand the method overriding with a simple C# code example:

using System;

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("The animal makes a generic sound.");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The dog barks.");
    }
}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The cat meows.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myAnimal.MakeSound(); // Output: The animal makes a generic sound.
        myDog.MakeSound();    // Output: The dog barks.
        myCat.MakeSound();    // Output: The cat meows.
    }
}

Output:

The animal makes a generic sound.
The dog barks.
The cat meows.

Code Explanation:

In this code, we have a base class Animal with a virtual method MakeSound, which is overridden in the derived classes Dog and Cat.

By creating instances of these derived classes and calling the MakeSound method, we observe how method overriding allows us to achieve polymorphic behavior, resulting in different animal sounds being produced based on the actual type of the object.

Important Key Points About Method Overriding in C#

Important key points about method overriding in C#:

• Inheritance Requirement: Method overriding is directly related to inheritance. It can only be applied to a method in a derived class that’s inherited from a base class.
• Keyword Usage: In C#, the base class method that you intend to override should be marked as virtual, abstract, or override.
• Method Signature Preservation: When you override a method, the method name, return type, and parameter list must match exactly with the base class method. Any deviation in the method signature will result in a compile-time error.
• Runtime Polymorphism: The power of method overriding lies in its ability to achieve runtime polymorphism. When you call an overridden method on an object, the actual implementation that gets executed is determined by the type of the object at runtime, not at compile time.
• Hiding or Shadowing: Overriding is about replacing the base class method entirely, while shadowing creates a new method in the derived class with the same name, without any relation to the base class method.
• Sealed Methods: In some cases, you may want to prevent further overriding of a method. In such scenarios, you can mark the method in the derived class as sealed. This ensures that no further overrides are allowed.
• Polymorphic Behavior: Method overriding facilitates the creation of polymorphic behavior, where you can work with objects of different derived classes through a common interface.

Overriding vs Overloading in C#

Here’ is the key differences between method overloading and method overriding in C#:

FAQs:

References: Differencebetween.com , c-sharpcorner.com

Recommended Articles:

• C# Early Binding vs Late Binding
• Polymorphism in C#
• C# Struct vs Class |Top 15+ Differences Between C# Struct and Class
• Static vs Singleton in C#: Understanding the Key Differences
• Garbage Collection in C#
• SOLID Design Principles in C#: A Complete Example
• 10 Difference between interface and abstract class In C#
• Generic Delegates in C# With Examples: Func, Action, and Predicate delegates
• Local vs Global Variables
• Constructors in C#: A Comprehensive Guide with Code Examples
• C# Tutorial

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• C# Program to Capitalize the First Character of Each Word in a String - February 21, 2024
• C# Program to Find the Longest Word in a String - February 19, 2024
• How to Reverse an Array in C# with Examples - February 12, 2024