Debugging scenarioHard~12 min

Interview question

A derived object calls different methods depending on the variable's declared type. How do overloads, overrides, and new method hiding differ?

Overload resolution, overriding, and method hiding

Separates compile-time overload selection from runtime virtual dispatch and diagnoses method hiding through a base reference.

1Say itAnswer out loud first

2CompareCompare with Core answer

3RefineRefine with Stronger and Advanced

TL;DR

Overloading means several methods share a name but have different parameter lists; the compiler chooses the best applicable overload from the argument expressions and their compile-time types. Overriding replaces a virtual or abstract base implementation, and runtime dispatch selects the most-derived override for the actual object. Declaring new hides a base member instead of participating in that virtual slot, so the chosen member depends on the variable's declared type. I use override for polymorphic behavior and avoid hiding unless the distinction is deliberate and clearly documented.

Full answer below

Practice focus

Compile-time overload resolution, runtime virtual dispatch, override contracts, new method hiding, static type, dynamic, optional parameters, and API evolution.

Answer first

Answer path

Core answer first, then checkpoints toward a stronger answer.

Start
Core answer
Start here. This is the direct spoken answer to practice first.
Why this question matters
Several C# features use the same method name but select behavior at different times. Predicting the call requires separating the compile-time candidate from runtime virtual dispatch.
Overloading means several methods share a name but have different parameter lists; the compiler chooses the best applicable overload from the argument expressions and their compile-time types. Overriding replaces a virtual or abstract base implementation, and runtime dispatch selects the most-derived override for the actual object. Declaring new hides a base member instead of participating in that virtual slot, so the chosen member depends on the variable's declared type. I use override for polymorphic behavior and avoid hiding unless the distinction is deliberate and clearly documented.
Checkpoint
Stronger answer
Optional upgrade with examples, trade-offs, and sharper phrasing.
If Dog : Animal overrides Speak, then Animal animal = new Dog(); animal.Speak() calls the dog's override. If Dog merely declares new Speak, the same base-typed call uses the base member, while a dog-typed variable sees the hidden member. Overload selection happens first: an overload accepting Animal may be selected even when the runtime object is a dog, unless the selected member is itself virtual. A dynamic argument defers overload binding to runtime, but that trades compiler checking for runtime binder failures.
Finish
Advanced answer
Optional deeper angle for production judgment and nuance.
Optional argument values are also baked into the caller at compile time, so changing a library's default does not change already compiled callers until they rebuild. Adding an overload can make source recompilation choose a different method or become ambiguous even when existing binaries still run. Virtual calls from constructors are risky because a derived override can run before derived initialization is complete. In production API design I prefer distinct names when overload intent is not obvious, keep virtual contracts narrow, and use compatibility tests for shared libraries. When debugging, I inspect the receiver's compile-time type, the selected signature, whether that member is virtual, and the runtime type in that order.

Review signals

Use these to catch weak phrasing, shallow reasoning, and risky claims.

Common mistakesCandidateCommon mistakesMistakes that weaken the answer or signal shallow understanding.Open details

Details

Assuming runtime type chooses among every overload automatically.
Using new when the design requires polymorphic override behavior.
Changing optional parameter defaults and expecting deployed callers to pick them up immediately.
Calling overridable members from a base constructor before derived state is initialized.

Red flagsCandidateSigns the approach is fragileSignals that an interviewer may treat as risky.Open details

Details

Cannot separate overload selection from virtual dispatch.
Fixes method hiding by casting at call sites instead of correcting the contract.
Adds overloads to a public library without source compatibility checks.
Uses dynamic only to make an ambiguous API compile.

Follow-up prompts

Quick interviewer prompts inside this drill.

Follow-up questionsCandidateFollow-up questionsLikely next questions after the main answer.Open details

Details

Treat these as the next interviewer turn. Answer one out loud, then save the gap in your practice notes.

What happens when an overload accepts Animal but the object is a Dog?
Why can changing an optional default be a binary-versioning surprise?
When is method hiding with new legitimate?

Continue practice

No explicit flow link is set yet, so these are nearby drills from the same path or taxonomy.

Abstraction vs encapsulationConcept question / Easy / ~5 minContinue Access modifiersConcept question / Easy / ~5 minContinue ActionResult vs Typed ResultsComparison question / Medium / ~7 minContinue

Debugging scenarioHard~12 min

Interview question

A derived object calls different methods depending on the variable's declared type. How do overloads, overrides, and new method hiding differ?

Overload resolution, overriding, and method hiding

Separates compile-time overload selection from runtime virtual dispatch and diagnoses method hiding through a base reference.

1Say itAnswer out loud first

2CompareCompare with Core answer

3RefineRefine with Stronger and Advanced

TL;DR

Full answer below

Practice focus

Compile-time overload resolution, runtime virtual dispatch, override contracts, new method hiding, static type, dynamic, optional parameters, and API evolution.

Answer first

Answer path

Core answer first, then checkpoints toward a stronger answer.

Start
Core answer
Start here. This is the direct spoken answer to practice first.
Why this question matters
Several C# features use the same method name but select behavior at different times. Predicting the call requires separating the compile-time candidate from runtime virtual dispatch.
Overloading means several methods share a name but have different parameter lists; the compiler chooses the best applicable overload from the argument expressions and their compile-time types. Overriding replaces a virtual or abstract base implementation, and runtime dispatch selects the most-derived override for the actual object. Declaring new hides a base member instead of participating in that virtual slot, so the chosen member depends on the variable's declared type. I use override for polymorphic behavior and avoid hiding unless the distinction is deliberate and clearly documented.
Checkpoint
Stronger answer
Optional upgrade with examples, trade-offs, and sharper phrasing.
If Dog : Animal overrides Speak, then Animal animal = new Dog(); animal.Speak() calls the dog's override. If Dog merely declares new Speak, the same base-typed call uses the base member, while a dog-typed variable sees the hidden member. Overload selection happens first: an overload accepting Animal may be selected even when the runtime object is a dog, unless the selected member is itself virtual. A dynamic argument defers overload binding to runtime, but that trades compiler checking for runtime binder failures.
Finish
Advanced answer
Optional deeper angle for production judgment and nuance.
Optional argument values are also baked into the caller at compile time, so changing a library's default does not change already compiled callers until they rebuild. Adding an overload can make source recompilation choose a different method or become ambiguous even when existing binaries still run. Virtual calls from constructors are risky because a derived override can run before derived initialization is complete. In production API design I prefer distinct names when overload intent is not obvious, keep virtual contracts narrow, and use compatibility tests for shared libraries. When debugging, I inspect the receiver's compile-time type, the selected signature, whether that member is virtual, and the runtime type in that order.

Review signals

Use these to catch weak phrasing, shallow reasoning, and risky claims.

Common mistakesCandidateCommon mistakesMistakes that weaken the answer or signal shallow understanding.Open details

Details

Assuming runtime type chooses among every overload automatically.
Using new when the design requires polymorphic override behavior.
Changing optional parameter defaults and expecting deployed callers to pick them up immediately.
Calling overridable members from a base constructor before derived state is initialized.

Red flagsCandidateSigns the approach is fragileSignals that an interviewer may treat as risky.Open details

Details

Cannot separate overload selection from virtual dispatch.
Fixes method hiding by casting at call sites instead of correcting the contract.
Adds overloads to a public library without source compatibility checks.
Uses dynamic only to make an ambiguous API compile.

Follow-up prompts

Quick interviewer prompts inside this drill.

Follow-up questionsCandidateFollow-up questionsLikely next questions after the main answer.Open details

Details

Treat these as the next interviewer turn. Answer one out loud, then save the gap in your practice notes.

What happens when an overload accepts Animal but the object is a Dog?
Why can changing an optional default be a binary-versioning surprise?
When is method hiding with new legitimate?

Continue practice

No explicit flow link is set yet, so these are nearby drills from the same path or taxonomy.

A derived object calls different methods depending on the variable's declared type. How do overloads, overrides, and new method hiding differ?

Practice focus

Answer path

Why this question matters

Review signals

Follow-up prompts

Continue practice

A derived object calls different methods depending on the variable's declared type. How do overloads, overrides, and new method hiding differ?

Practice focus

Answer path

Why this question matters

Review signals

Follow-up prompts

Continue practice