How does C# code become IL? Explain lowering with examples such as foreach, using, lock, string concatenation and switch.

How I would answer this in an interview

Roslyn compiles C# in phases: parse to syntax trees, bind names and types (semantic analysis), lower high-level constructs into simpler ones, then emit IL. Lowering is where much of C#'s convenience syntax disappears: foreach, using, lock, string interpolation/concatenation, switch, lambdas, async, iterators, pattern matching all become plain loops, try/finally blocks, method calls and generated classes. Knowing the lowered forms explains performance and behaviour.

1. foreach

foreach (var line in orderLines) Process(line);   // List<OrderLine>

lowers to:

List<OrderLine>.Enumerator e = orderLines.GetEnumerator();   // struct enumerator - no allocation
try
{
    while (e.MoveNext()) { var line = e.Current; Process(line); }
}
finally { ((IDisposable)e).Dispose(); }

• Arrays and spans lower to for loops with an index (no enumerator, bounds-check elimination).
• Through IEnumerable<T>, the enumerator is an interface → boxed if struct, interface calls.
• Since C# 5, the loop variable is declared inside the loop (fresh per iteration for closures).
• await foreach lowers to GetAsyncEnumerator, await MoveNextAsync(), await DisposeAsync() in finally.

2. using

using var stream = File.OpenRead(path);
Process(stream);

lowers to:

FileStream stream = File.OpenRead(path);
try { Process(stream); }
finally { if (stream != null) ((IDisposable)stream).Dispose(); }

For struct disposables, the compiler calls Dispose without boxing (constrained call). await using calls DisposeAsync() and awaits it. Pattern-based Dispose works for ref structs.

3. lock

lock (_sync) { _balance -= amount; }

lowers to (for object locks):

object obj = _sync; bool lockTaken = false;
try
{
    Monitor.Enter(obj, ref lockTaken);
    _balance -= amount;
}
finally { if (lockTaken) Monitor.Exit(obj); }

In C# 13 / .NET 9, if the lock expression is a System.Threading.Lock, it lowers to using (_lock.EnterScope()) { ... } — the new dedicated lock type with a faster implementation. (Converting a Lock to object and locking on it falls back to Monitor — the compiler warns.)

4. String concatenation and interpolation

string a = first + " " + last;              // string.Concat(first, " ", last) - single allocation
string b = $"Order {id} total {total:C}";   // C# 10+: DefaultInterpolatedStringHandler

b lowers to:

var h = new DefaultInterpolatedStringHandler(literalLength: 13, formattedCount: 2);
h.AppendLiteral("Order ");
h.AppendFormatted(id);
h.AppendLiteral(" total ");
h.AppendFormatted(total, "C");
string b = h.ToStringAndClear();

• No boxing of id/total (generic AppendFormatted<T>), pooled buffer, one final string.
• Constant-only interpolations become constants.
• += in loops still creates a new string each iteration (lowers to Concat per iteration) — use StringBuilder.
• Custom handlers ([InterpolatedStringHandler]) let APIs like logging avoid work when disabled.

5. switch

string Describe(OrderStatus s) => s switch { OrderStatus.Paid => "Paid", OrderStatus.Shipped => "Shipped", _ => "Other" };

• Dense integer/enum constants → IL switch jump table.
• Sparse constants → binary search of comparisons.
• Strings → compute a hash (or check length/characters) then compare (ComputeStringHash + string.op_Equality), or length-based dispatch in newer compilers.
• Patterns → a decision DAG of type tests (isinst), property reads and comparisons, sharing tests between arms.
• Switch expressions that aren't exhaustive get a throw of SwitchExpressionException.

6. Other lowerings worth knowing

• Lambdas/closures → display classes and cached delegates.
• async → state machine struct + AsyncTaskMethodBuilder.
• Iterators → state machine classes.
• Null-conditional/coalescing → temporaries and branches.
• Records → generated members.
• Collection expressions → arrays, spans with inline arrays, CollectionsMarshal operations.
• params ReadOnlySpan<T> → inline arrays on the stack.

7. How to see it

SharpLab's "C#" output shows lowered C#; ILSpy with "show compiler-generated code" settings; IL view for exact instructions.

8. A production example

A hot loop built log keys with key += part over ~50 parts per item, allocating ~50 strings per item. SharpLab's lowered view made the repeated string.Concat obvious; switching to string.Create/StringBuilder cut allocations dramatically. In another case, a team locked on a Lock instance typed as object after a refactor; the C# 13 warning showed it had silently fallen back to Monitor, and fixing the field type restored the faster EnterScope path.