Concept questionMedium~7 min.NET Collections & LINQ Essentials / 7 of 15

Interview question

What happens when a C# method uses yield return, and what happens to resources if enumeration stops early?

How yield iterators execute and clean up resources

Describes lazy iterator execution, state-machine behavior, early termination, resource disposal, and repeat-enumeration consequences.

1Say itAnswer out loud first

2CompareCompare with Core answer

3RefineRefine with Stronger and Advanced

TL;DR

A method containing yield return is compiled into an iterator state machine. Calling the method returns an enumerable without normally running the body to completion; each MoveNext continues execution until the next yielded value or the end. Local variables become state carried between those calls. If the consumer uses foreach, the enumerator is disposed when the loop ends, including when it exits early, so finally blocks in the iterator can release resources.

Full answer below

Practice focus

Iterator state machines, deferred execution, MoveNext, early termination, finally blocks, enumerator disposal, repeat enumeration, and streaming.

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
An iterator method looks like a normal method but its body advances in stages controlled by the consumer. Resource lifetime follows enumeration, not merely the call that produced the sequence.
A method containing yield return is compiled into an iterator state machine. Calling the method returns an enumerable without normally running the body to completion; each MoveNext continues execution until the next yielded value or the end. Local variables become state carried between those calls. If the consumer uses foreach, the enumerator is disposed when the loop ends, including when it exits early, so finally blocks in the iterator can release resources.
Checkpoint
Stronger answer
Optional upgrade with examples, trade-offs, and sharper phrasing.
For example, an iterator can open a file inside a using, yield parsed lines one at a time, and close the file when enumeration completes or the consumer breaks from foreach. The resource remains open while the enumerator is active, which means returning a lazy sequence can move I/O lifetime outside the method's obvious scope. Enumerating the sequence again usually creates a new enumerator and reruns the body, potentially reopening the file or repeating side effects. Materializing once is appropriate when callers need a stable reusable result.
Finish
Advanced answer
Optional deeper angle for production judgment and nuance.
I keep iterator bodies free of business side effects because partial enumeration means only part of the body may run. Consumers that manually obtain an enumerator must dispose it; foreach and LINQ operators normally manage that boundary. Exceptions are also deferred until the consumer reaches the failing part, so validation placed inside the iterator may happen much later than the initial method call. For asynchronous streams, IAsyncEnumerable<T> uses MoveNextAsync and await foreach, with cancellation and asynchronous disposal forming part of the contract. In production I document one-shot or resource-backed sequences and avoid exposing a lazy iterator after its required context, stream, or scope has already been disposed.

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 the full iterator body runs when the method is called.
Opening a resource outside the iterator and disposing it before enumeration begins.
Adding side effects that silently run only for the portion the consumer enumerates.
Manually using an enumerator without disposing it after early termination.

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

Details

Cannot explain the role of MoveNext in advancing the method body.
Returns a lazy sequence whose required dependency scope has already ended.
Enumerates a resource-backed iterator repeatedly without noticing repeated I/O.
Expects validation inside the iterator to fail at sequence creation time.

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.

When does a finally block inside an iterator run?
How does an async iterator change the execution contract?
When would you materialize rather than return IEnumerable?

Continue the section

Next in .NET Collections & LINQ Essentials: LINQ execution timing

Step 8 of 15

LINQ deferred execution and multiple enumeration

Opening drill

Concept questionMedium~7 min.NET Collections & LINQ Essentials / 7 of 15

Interview question

What happens when a C# method uses yield return, and what happens to resources if enumeration stops early?

How yield iterators execute and clean up resources

Describes lazy iterator execution, state-machine behavior, early termination, resource disposal, and repeat-enumeration consequences.

1Say itAnswer out loud first

2CompareCompare with Core answer

3RefineRefine with Stronger and Advanced

TL;DR

Full answer below

Practice focus

Iterator state machines, deferred execution, MoveNext, early termination, finally blocks, enumerator disposal, repeat enumeration, and streaming.

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
An iterator method looks like a normal method but its body advances in stages controlled by the consumer. Resource lifetime follows enumeration, not merely the call that produced the sequence.
A method containing yield return is compiled into an iterator state machine. Calling the method returns an enumerable without normally running the body to completion; each MoveNext continues execution until the next yielded value or the end. Local variables become state carried between those calls. If the consumer uses foreach, the enumerator is disposed when the loop ends, including when it exits early, so finally blocks in the iterator can release resources.
Checkpoint
Stronger answer
Optional upgrade with examples, trade-offs, and sharper phrasing.
For example, an iterator can open a file inside a using, yield parsed lines one at a time, and close the file when enumeration completes or the consumer breaks from foreach. The resource remains open while the enumerator is active, which means returning a lazy sequence can move I/O lifetime outside the method's obvious scope. Enumerating the sequence again usually creates a new enumerator and reruns the body, potentially reopening the file or repeating side effects. Materializing once is appropriate when callers need a stable reusable result.
Finish
Advanced answer
Optional deeper angle for production judgment and nuance.
I keep iterator bodies free of business side effects because partial enumeration means only part of the body may run. Consumers that manually obtain an enumerator must dispose it; foreach and LINQ operators normally manage that boundary. Exceptions are also deferred until the consumer reaches the failing part, so validation placed inside the iterator may happen much later than the initial method call. For asynchronous streams, IAsyncEnumerable<T> uses MoveNextAsync and await foreach, with cancellation and asynchronous disposal forming part of the contract. In production I document one-shot or resource-backed sequences and avoid exposing a lazy iterator after its required context, stream, or scope has already been disposed.

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 the full iterator body runs when the method is called.
Opening a resource outside the iterator and disposing it before enumeration begins.
Adding side effects that silently run only for the portion the consumer enumerates.
Manually using an enumerator without disposing it after early termination.

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

Details

Cannot explain the role of MoveNext in advancing the method body.
Returns a lazy sequence whose required dependency scope has already ended.
Enumerates a resource-backed iterator repeatedly without noticing repeated I/O.
Expects validation inside the iterator to fail at sequence creation time.

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.

When does a finally block inside an iterator run?
How does an async iterator change the execution contract?
When would you materialize rather than return IEnumerable?

Continue the section

Next in .NET Collections & LINQ Essentials: LINQ execution timing

Step 8 of 15

LINQ deferred execution and multiple enumeration

What happens when a C# method uses yield return, and what happens to resources if enumeration stops early?

Practice focus

Answer path

Why this question matters

Review signals

Follow-up prompts

Continue the section

What happens when a C# method uses yield return, and what happens to resources if enumeration stops early?

Practice focus

Answer path

Why this question matters

Review signals

Follow-up prompts

Continue the section