What Is Method Overloading in C#/Visual Basic

Method overloading is a simple and very useful concept in computer programming. We’re in luck because VB.Net and C# can do method overloading!

What is method overloading?

Basically, it’s writing two or more methods with the same name but with a different signature. This means that if two or more methods have pretty much the same behavior, it’s possible to simply give them the same name but different return value and parameters. Let me show you an example.

Example Please!

I created a simple class named Calculator in a new Console Application project.

C#

using System.Collections.Generic;

namespace MethodOverloading
{
    public class Calculator
    {
        public Queue LastResults { get; set; }

        public Calculator()
        {
            LastResults = new Queue();
        }

        public int AddNumbers(int NumberOne, int NumberTwo)
        {
            int Result = NumberOne + NumberTwo;

            return Result;
        }

        public double AddNumbers(double NumberOne, double NumberTwo)
        {
            double Result = NumberOne + NumberTwo;

            return Result;
        }
    }
}

Visual Basic

Public Class Calculator
    Public Property LastResults As Queue(Of Double)

    Public Sub New()
        LastResults = New Queue(Of Double)
    End Sub

    Public Function AddNumbers(ByVal NumberOne As Integer, ByVal NumberTwo As Integer) As Integer
        Dim Result As Integer
        Result = NumberOne + NumberTwo

        Return Result
    End Function

    Public Function AddNumbers(ByVal NumberOne As Double, ByVal NumberTwo As Double) As Double
        Dim Result As Double
        Result = NumberOne + NumberTwo

        Return Result
    End Function
End Class

In this class you can see that I’ve added a method with the same name twice. This is what overloading is about. The name is the same but the signature is not. The first one returns int and takes (int,int) as parameters while the second one returns double and takes (double,double) as parameters. LastResults is just a class variable I added to make it sound a bit more like it’s going to be an actual calculator.

How to Use

My Program.cs/MethodOverloading.vb class looks like the code below.

C#

Visual Basic

What I want to show you is that when you instantiate a new Calculator and call the AddNumbers method, you actually see two overloads (the current one +1 as written in the completion)! That’s exactly what we want. I then have the choice of both methods to use.

C#

using System;

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

            double DoubleResult = MyCalculator.AddNumbers(15.32, 64.21);
            int IntResult = MyCalculator.AddNumbers(67, 98);

            Console.WriteLine("The Double Result: {0}", DoubleResult);
            Console.WriteLine("The Int Result: {0}", IntResult);
            Console.ReadKey();
        }        
    }
}

Visual Basic

Module MethodOverloading

    Sub Main()
        Dim MyCalculator As New Calculator()

        Dim DoubleResult As Double
        DoubleResult = MyCalculator.AddNumbers(15.32, 64.21)

        Dim IntResult As Integer
        IntResult = MyCalculator.AddNumbers(67, 98)

        Console.WriteLine("The Double Result: {0}", DoubleResult)
        Console.WriteLine("The Int Result: {0}", IntResult)
        Console.ReadKey()
    End Sub

End Module

In the code above, I use both methods and display the result in the console.

It Works!

As you can see, one method was called with double values and returned a double and the other one with int values and returned an int. Two methods, same name, different signatures. You will see this on multiple occasions in the .Net Framework and should take advantage of it in your own code as well!

When you see two method that do very similar behavior enough to give them the same name, that’s a potential candidate for overloading.

YouTube

C#

Visual Basic