🔧 Struct in foreach = Silent No-Op
Mutating a struct’s field while iterating a List<T> with foreach compiles fine, runs fine, and changes absolutely nothing — because C# hands you a COPY of each struct, not a reference to the one in the list.
🐞 The Problem
public struct Point { public int X; public int Y; }
var points = new List<Point> { new Point { X = 1, Y = 1 } };
foreach (var p in points)
{
p.X = 99; // compiles fine
}
Console.WriteLine(points[0].X); // still 1, not 99
🔍 Why This Happens
struct is a value type. foreach's iteration variable 'p' is a COPY of the item at each position - mutating 'p' only mutates that local copy, which is discarded the instant the loop moves to the next item. This is different from a class, where the foreach variable is a reference and mutations ARE visible.
✅ Fix 1: Use an Indexed for Loop Instead
- Indexing into the list (points[i].X = 99) mutates the actual struct stored in the list, not a copy.
- Simplest fix, no API changes, works in any C# version.
🔢 Indexed for Loop
for (int i = 0; i < points.Count; i++)
{
var p = points[i];
p.X = 99;
points[i] = p; // write the modified copy back explicitly
}
✅ Fix 2: Make It a Class If It’s Meant to Be Mutated
- If you’re routinely mutating instances after creation, that’s usually a sign the type should be a reference type (class), not a value type (struct).
- Reserve struct for small, immutable, short-lived data (a Point you replace, not update, is a healthy use of struct).
⚠️ The Same Trap Hides in LINQ Too
- points.Where(p => { p.X = 99; return true; }) has the exact same problem — the lambda parameter is a copy.
- The compiler does catch and block this for readonly struct fields specifically, but plain mutable struct fields compile silently.
The compiler won’t warn you here because nothing is technically wrong — it’s doing exactly what value-type semantics say it should; the bug is in expecting reference semantics from a value type.
