A set of lambdas sees surprising variable values and keeps an object alive longer than expected. How do closures work in C#?

Closures, captured variables, and object lifetimes

Explains what a lambda captures, how captured state is shared, and why a long-lived callback can retain more memory than expected.

1Say itAnswer out loud first

2CompareCompare with Core answer

3RefineRefine with Stronger and Advanced

TL;DR

A closure is a delegate whose code uses variables from an enclosing scope. The compiler moves captured variables into storage that remains reachable for as long as the delegate needs it. Lambdas capture variables, not frozen copies of their current values, so several lambdas can observe the same variable after it changes. If I need each callback to preserve a separate value, I create a new local for that iteration or pass the value explicitly into a helper.

Full answer below

Practice focus

Closure semantics, captured variables, loop variables, shared mutable state, compiler-generated storage, allocation, and callback lifetime.

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
A lambda can outlive the method that created it, so captured local state needs somewhere to live. That affects both the values later observed and the objects retained by the callback.
A closure is a delegate whose code uses variables from an enclosing scope. The compiler moves captured variables into storage that remains reachable for as long as the delegate needs it. Lambdas capture variables, not frozen copies of their current values, so several lambdas can observe the same variable after it changes. If I need each callback to preserve a separate value, I create a new local for that iteration or pass the value explicitly into a helper.
Checkpoint
Stronger answer
Optional upgrade with examples, trade-offs, and sharper phrasing.
For example, callbacks created in a loop can all observe a later value when they share the same captured variable. Modern foreach creates a fresh iteration variable, but an outer local or a classic index can still be shared unless I copy it inside the loop. Capturing also captures a route back to the whole object, not only the one property mentioned in the lambda. A timer, event publisher, cache, or static delegate can therefore keep that object graph alive until the callback is removed.

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 a lambda always captures a snapshot of each local value.
Capturing an outer loop variable and expecting every callback to own a separate copy.
Storing a callback long term without considering that it captures this or scoped services.
Mutating captured state from concurrent callbacks without synchronization.

A set of lambdas sees surprising variable values and keeps an object alive longer than expected. How do closures work in C#?

Practice focus

Answer path

Why this question matters

Review signals

Follow-up prompts

Continue the section

Skill areas

Suggest an improvement