Method overloading in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of overloaded methods with different parameter types

What is the output of this C# program?

C Sharp (C#)

using System;
class Program {
    static void Print(int x) {
        Console.WriteLine("Integer: " + x);
    }
    static void Print(string x) {
        Console.WriteLine("String: " + x);
    }
    static void Main() {
        Print(5);
        Print("hello");
    }
}

A Integer: 5\nInteger: hello

B Integer: 5\nString: hello

C String: 5\nInteger: hello

D String: 5\nString: hello

💡 Hint

Look at the method signatures and which one matches the argument type.

The method Print(int x) is called when an integer is passed, and Print(string x) is called when a string is passed. So the output matches the argument types.

❓ Predict Output

intermediate

Output when overloaded methods have default parameters

What will this program print?

C Sharp (C#)

using System;
class Program {
    static void Show(int x, int y = 10) {
        Console.WriteLine(x + y);
    }
    static void Show(int x) {
        Console.WriteLine(x * 2);
    }
    static void Main() {
        Show(5);
    }
}

A 15

B 10

C Syntax error

D Runtime error

💡 Hint

Check if these two methods can coexist with these signatures.

These two methods cause a compile-time error because Show(int x) and Show(int x, int y = 10) have ambiguous calls when calling Show(5). The compiler cannot decide which method to call.

🔧 Debug

advanced

Identify the error in overloaded methods with params keyword

Why does this code cause a compilation error?

C Sharp (C#)

using System;
class Program {
    static void Display(params int[] numbers) {
        Console.WriteLine("Params method");
    }
    static void Display(int x, int y) {
        Console.WriteLine("Two int method");
    }
    static void Main() {
        Display(1, 2);
    }
}

A No error, output is "Two int method"

B No error, output is "Params method"

C Ambiguous call error because both methods match the call Display(1, 2)

D Runtime error due to params array

💡 Hint

Think about how the compiler chooses between a params method and a fixed parameter method.

The call Display(1, 2) matches both Display(int x, int y) and Display(params int[] numbers). However, the compiler prefers the method with fixed parameters over the params array, so Display(int x, int y) is called.

❓ Predict Output

advanced

Output of overloaded methods with inheritance and type casting

What is the output of this program?

C Sharp (C#)

using System;
class Animal {}
class Dog : Animal {}
class Program {
    static void Speak(Animal a) {
        Console.WriteLine("Animal speaks");
    }
    static void Speak(Dog d) {
        Console.WriteLine("Dog barks");
    }
    static void Main() {
        Animal a = new Dog();
        Speak(a);
    }
}

A Animal speaks

B Dog barks

C Runtime error

D Compilation error

💡 Hint

Consider the static type of the variable used in the method call.

The variable a is of type Animal, so the method Speak(Animal a) is called, even though the actual object is a Dog. Method overloading is resolved at compile time based on variable type.

❓ Predict Output

expert

Output of overloaded methods with ref and out parameters

What is the output of this program?

C Sharp (C#)

using System;
class Program {
    static void Modify(ref int x) {
        x = x + 10;
    }
    static void Modify(out int x) {
        x = 20;
    }
    static void Main() {
        int a = 5;
        Modify(ref a);
        Console.WriteLine(a);
        int b;
        Modify(out b);
        Console.WriteLine(b);
    }
}

A Runtime error due to uninitialized variable

B 15\n0

C Compilation error due to ambiguous call

D 15\n20

💡 Hint

Note how ref and out parameters differ and how they affect method selection.

The call Modify(ref a) calls the method with ref parameter, adding 10 to 5 resulting in 15. The call Modify(out b) calls the method with out parameter, setting b to 20. So the output is 15 and then 20.