Method Overloading and Method Overriding in C#

Polymorphism

Polymorphism simply means "many forms" and hence means "having many forms" in C# or for that matter in any Object Oriented Programming language.

Method overloading and method overriding in C# implies one name with multiple functions. In method overloading and method overriding in C# we declare methods with the same name and different parameters in the same class or methods with the same name and same parameters in different classes.

There are two types of method overloading and method overriding in C#. They are the following.

Static Polymorphism

Method overloading and operator overloading are examples. It is also called early binding.

Dynamic Polymorphism

Method overriding and Virtual functions are examples. it is also called late binding.

Example of Method Overloading

class Program {
    void hello() {
        Console.WriteLine("HelloIndia");
    }
    void hello(string s) {
        Console.WriteLine(s);
    }
    void hello(string s, int marks) {
        Console.WriteLine(s + " Your marks is " + marks);
    }
    public static void Main() {
        Program p1 = new Program();
        p1.hello();
        p1.hello("hello");
        p1.hello("siddique", 58);
        Console.ReadLine();
    }

Output



So here we saw method overloading.

A method hello() that is declared in the base class A and not redeclared in classes B but B is inherited from A. So see the code and output.

Program
{
    class A
    {
        public void hello()
        {
            Console.WriteLine("helloWorld");
        }
    }
    class B: A {}
    public static void Main()
    {
        A a = new A();
        a.hello(); // output --> "helloWorld"
        B b = new B();
        b.hello(); // output --> "helloWorld"
        Console.ReadLine();
    }

Output



The method hello() can be overridden in classes B.

class Program
{
    class A
    {
        public void hello()
        {
            Console.WriteLine("helloworld A");
        }
    }
    class B: A
    {
        public void hello()
        {
            Console.WriteLine("helloworld B");
        }
    }
    public static void Main()
    {
        A a;
        B b;
        a = new A();
        b = new B();
        a.hello(); // output --> "helloworld A"
        b.hello(); // output --> "helloworld B"
        a = new B();
        a.hello(); // output --> "helloworld A"
        Console.ReadLine();
    }

output



The output is not really what we, say from Java, expected. The method hello() is a non-virtual method. C# requires the use of the keyword virtual for a method to actually be virtual.

Example

class Program
{
    class A
    {
        public virtual void hello()
        {
            Console.WriteLine("helloworld A");
        }
    }

    class B: A
    {
        public override void hello()
        {
            Console.WriteLine("helloworld B");
        }
    }

    public static void Main()
    {
        A a;
        B b;

        a = new A();
        b = new B();
        a.hello(); // output --> "helloworld A"
        b.hello(); // output --> "helloworld B"

        a = new B();
        a.hello(); // output --> "helloworld B"
        Console.ReadLine();
    }

Output



Method Hiding

C# not only supports method overriding, but also method hiding. Simply put, if a method is not overriding the derived method, it is hiding it. A hiding method must be declared using the new keyword. The correct class definition is as in the following:

class Program
{
    class A
    {
        public void hello()
        {
            Console.WriteLine("helloworld A");
        }
    }

    class B: A
    {
        public new void hello()
        {
            Console.WriteLine("helloworld B");
        }
    }

    public static void Main()
    {
        A a;
        B b;

        a = new A();
        b = new B();
        a.hello(); // output --> "helloworld A"
        b.hello(); // output --> "helloworld B"

        a = new B();
        a.hello(); // output --> "helloworld A"
        Console.ReadLine();
    }

Output



Combining Method Overriding and Hiding

Methods of a derived class can both be virtual and at the same time hide the derived method. In order to declare such a method, both keywords virtual and new must be used in the method declaration as in the following:

class A
{
    public void hello() {}
}
class B: A
{
    public virtual new void hello() {}
}

A class C can now declare a method hello() that either overrides or hides hello() from class B: class C: B {
    public override void hello() {}
    // or
    public new void hello() {}
}

Conclusion

Only methods in base classes need not override or hide derived methods. All methods in derived classes require to be either defined as new or be overriden.