Runtime cost of dynamic type resolution in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of dynamic vs static method call

What is the output of this C# code snippet?

C Sharp (C#)

using System;
class Program {
    static void Main() {
        dynamic d = "hello";
        string s = "hello";
        Console.WriteLine(d.ToUpper());
        Console.WriteLine(s.ToUpper());
    }
}

A HELLO\nhello

B hello\nhello

C HELLO\nHELLO

D hello\nHELLO

💡 Hint

Both dynamic and static strings call the same method, but dynamic resolution happens at runtime.

Both d.ToUpper() and s.ToUpper() call the ToUpper method on a string, which returns the uppercase version. The output is HELLO twice.

❓ Predict Output

intermediate

Performance difference in repeated dynamic calls

Consider this code measuring elapsed time for 1 million calls. What is the expected output pattern?

C Sharp (C#)

using System;
using System.Diagnostics;
class Program {
    static void Main() {
        dynamic d = "test";
        string s = "test";
        Stopwatch sw = new Stopwatch();

        sw.Start();
        for (int i = 0; i < 1000000; i++) {
            var x = d.ToUpper();
        }
        sw.Stop();
        Console.WriteLine("Dynamic: " + sw.ElapsedMilliseconds);

        sw.Restart();
        for (int i = 0; i < 1000000; i++) {
            var y = s.ToUpper();
        }
        sw.Stop();
        Console.WriteLine("Static: " + sw.ElapsedMilliseconds);
    }
}

A Code throws runtime exception

B Dynamic time < Static time

C Dynamic time == Static time

D Dynamic time > Static time

💡 Hint

Dynamic calls resolve method at runtime, adding overhead.

Dynamic calls use runtime type resolution, which is slower than static calls resolved at compile time. So dynamic calls take more time.

🔧 Debug

advanced

Identify the runtime error in dynamic invocation

What error does this code produce when run?

C Sharp (C#)

using System;
class Program {
    static void Main() {
        dynamic d = 10;
        Console.WriteLine(d.ToUpper());
    }
}

A RuntimeBinderException: 'int' does not contain a definition for 'ToUpper'

B NullReferenceException

C No error, prints 10

D SyntaxError

💡 Hint

Check if the type supports the called method.

The integer type does not have a ToUpper method. Dynamic invocation tries to call it at runtime and fails with a RuntimeBinderException.

🧠 Conceptual

advanced

Why does dynamic type resolution add runtime cost?

Which explanation best describes why dynamic type resolution in C# adds runtime cost?

A Because the compiler generates extra IL code to check types at runtime and invoke methods dynamically

B Because dynamic variables use more memory than static variables

C Because dynamic variables require manual type casting by the programmer

D Because dynamic variables are compiled to slower machine code

💡 Hint

Think about what happens behind the scenes when you use dynamic.

Dynamic variables cause the compiler to emit code that performs type checks and method lookups at runtime, which adds overhead compared to static calls resolved at compile time.

❓ Predict Output

expert

Output of mixed dynamic and static method calls with inheritance

What is the output of this C# program?

C Sharp (C#)

using System;
class Base {
    public virtual string GetName() => "Base";
}
class Derived : Base {
    public override string GetName() => "Derived";
}
class Program {
    static void Main() {
        Base b = new Derived();
        dynamic d = new Derived();
        Console.WriteLine(b.GetName());
        Console.WriteLine(d.GetName());
    }
}

A Base\nDerived

B Derived\nDerived

C Derived\nBase

D Base\nBase

💡 Hint

Remember how virtual methods behave with static and dynamic calls.

Both static and dynamic calls invoke the overridden method in Derived. So both print "Derived".