Runtime cost of dynamic type resolution in C Sharp (C#) - Mini Project: Build & Apply

Runtime Cost of Dynamic Type Resolution

📖 Scenario: Imagine you are building a simple calculator that can add numbers. Sometimes you know the types of numbers at compile time, and sometimes you only know them at runtime. You want to see how using dynamic types affects the speed of your program.

🎯 Goal: You will create two methods: one using static typing and one using dynamic typing. Then you will measure and compare the time each method takes to add numbers many times. This will help you understand the runtime cost of dynamic type resolution.

📋 What You'll Learn

Create a method called AddStatic that takes two int parameters and returns their sum.

Create a method called AddDynamic that takes two dynamic parameters and returns their sum.

Create a loop that calls each method 1,000,000 times and measures the time taken using Stopwatch.

Print the elapsed time for both methods to compare.

💡 Why This Matters

🌍 Real World

Understanding the cost of dynamic typing helps developers write faster programs when performance matters.

💼 Career

Many jobs require optimizing code performance and understanding how language features affect speed.

1

Create the static addition method

Write a method called AddStatic that takes two int parameters named a and b and returns their sum as an int.

C Sharp (C#)

using System;

// Write the AddStatic method below
// Your code here

Hint

Define a method with static int AddStatic(int a, int b) and return a + b.

2

Create the dynamic addition method

Add a method called AddDynamic that takes two dynamic parameters named a and b and returns their sum.

C Sharp (C#)

using System;

static int AddStatic(int a, int b)
{
    return a + b;
}

// Write the AddDynamic method below
// Your code here

Hint

Define AddDynamic with dynamic parameters and return a + b.

3

Measure time for static addition

Create a Stopwatch called swStatic. Use a for loop from 0 to 999,999 to call AddStatic(i, i). Start and stop the stopwatch around the loop.

C Sharp (C#)

using System;
using System.Diagnostics;

static int AddStatic(int a, int b)
{
    return a + b;
}

static dynamic AddDynamic(dynamic a, dynamic b)
{
    return a + b;
}

// Measure time for AddStatic
// Your code here

Hint

Use Stopwatch to time the loop calling AddStatic one million times.

4

Measure time for dynamic addition and print results

Create a Stopwatch called swDynamic. Use a for loop from 0 to 999,999 to call AddDynamic(i, i). Start and stop the stopwatch around the loop. Then print the elapsed milliseconds for both swStatic and swDynamic using Console.WriteLine.

C Sharp (C#)

using System;
using System.Diagnostics;

static int AddStatic(int a, int b)
{
    return a + b;
}

static dynamic AddDynamic(dynamic a, dynamic b)
{
    return a + b;
}

Stopwatch swStatic = new Stopwatch();
swStatic.Start();
for (int i = 0; i < 1000000; i++)
{
    AddStatic(i, i);
}
swStatic.Stop();

// Measure time for AddDynamic and print both times
// Your code here

Hint

Use another Stopwatch for AddDynamic. Print both elapsed times with Console.WriteLine.

Practice

1. What does dynamic keyword in C# do at runtime?

easy

A. It performs type checking at compile time

B. It prevents any type errors completely

C. It delays type checking until the program runs

D. It converts all types to strings automatically

Solution

1. Step 1: Understand the role of dynamic

   The dynamic keyword tells C# to skip compile-time type checking for that variable.

2. Step 2: Identify when type checking happens

   Type checking for dynamic variables happens only when the program runs, not before.

3. Final Answer:

   It delays type checking until the program runs -> Option C

4. Quick Check:

   Dynamic = runtime type check [OK]

Hint: Dynamic means check types only when running [OK]

Common Mistakes:

• Thinking dynamic checks types at compile time
• Believing dynamic prevents all errors
• Assuming dynamic converts types automatically

2. Which of the following is the correct syntax to declare a dynamic variable in C#?

easy

A. dynamic = 5 x;

B. var x = dynamic 5;

C. int dynamic x = 5;

D. dynamic x = 5;

Solution

1. Step 1: Recall dynamic variable declaration syntax

   In C#, you declare a dynamic variable by writing dynamic followed by the variable name and value.

2. Step 2: Check each option's syntax

   dynamic x = 5; matches the correct syntax: dynamic x = 5;. Others have incorrect order or keywords.

3. Final Answer:

   dynamic x = 5; -> Option D

4. Quick Check:

   Correct syntax = dynamic x = value [OK]

Hint: Use 'dynamic' before variable name [OK]

Common Mistakes:

• Putting 'dynamic' after 'var'
• Mixing 'int' and 'dynamic' keywords
• Incorrect order of assignment

3. What will be the output of this C# code?

dynamic x = 10;
dynamic y = "20";
Console.WriteLine(x + y);

medium

A. 1020

B. Runtime exception

C. 30

D. Compile-time error

Solution

1. Step 1: Analyze the types of variables

   Variable x is an integer 10, and y is a string "20".

2. Step 2: Understand dynamic addition behavior

   With dynamic types, the + operator at runtime performs string concatenation when one operand is a string, resulting in "1020".

3. Final Answer:

   1020 -> Option A

4. Quick Check:

   dynamic int + string = concatenation "1020" [OK]

Hint: Dynamic number + string = string concatenation [OK]

Common Mistakes:

• Expecting a runtime exception
• Thinking it adds numerically to 30
• Assuming compile-time error

4. Identify the error in this code snippet using dynamic types:

dynamic a = 5;
dynamic b = "hello";
var result = a - b;
Console.WriteLine(result);

medium

A. Runtime exception due to invalid operation

B. No error, outputs 0

C. Compile-time type mismatch error

D. Syntax error in variable declaration

Solution

1. Step 1: Check operation between dynamic variables

   Subtracting an integer and a string is invalid at runtime.

2. Step 2: Determine error type

   Since types are dynamic, error appears only when running, causing a runtime exception.

3. Final Answer:

   Runtime exception due to invalid operation -> Option A

4. Quick Check:

   Invalid dynamic operation = runtime exception [OK]

Hint: Invalid dynamic operations fail at runtime, not compile time [OK]

Common Mistakes:

• Expecting compile-time error
• Assuming subtraction works with string
• Ignoring runtime exceptions

5. You want to improve performance in a C# program that uses many dynamic variables. Which approach reduces runtime cost of dynamic type resolution?

hard

A. Avoid testing dynamic code to save time

B. Replace dynamic variables with explicit static types where possible

C. Add more dynamic variables to delay errors

D. Use dynamic variables everywhere for flexibility

Solution

1. Step 1: Understand runtime cost of dynamic

   Dynamic variables cause extra work at runtime to check types, slowing performance.

2. Step 2: Choose optimization strategy

   Replacing dynamic with static types lets compiler check types early, improving speed.

3. Final Answer:

   Replace dynamic variables with explicit static types where possible -> Option B

4. Quick Check:

   Static types reduce dynamic runtime cost [OK]

Hint: Use static types to speed up dynamic-heavy code [OK]

Common Mistakes:

• Thinking more dynamic variables improve speed
• Ignoring testing importance
• Believing dynamic has no runtime cost