🔧 You Switched to StringBuilder for Performance – It Got Slower
StringBuilder is the textbook answer for efficient string building in a loop, applied here to what turned out to be a very short, small loop – and the result actually runs slower than the plain string concatenation it replaced, contradicting the advice that led to the change in the first place.
🐞 The Problem
// "Optimized" version - only concatenates 3 short strings
var sb = new StringBuilder();
sb.Append(firstName);
sb.Append(" ");
sb.Append(lastName);
string fullName = sb.ToString();
// Measured slightly SLOWER than:
string fullName2 = firstName + " " + lastName;
🔍 Why This Happens
StringBuilder's advantage comes from avoiding repeated allocation of intermediate string objects across MANY concatenations in a loop - but StringBuilder itself has real overhead: allocating the builder object, its internal buffer, and finally converting back to a string with ToString(). For a SMALL, FIXED number of concatenations (a handful of known strings, not a loop with many iterations), the compiler-optimized "+" operator - which the C# compiler turns into a single String.Concat call for chained concatenations - can genuinely be faster, since it skips all of StringBuilder's setup overhead entirely.
✅ The Fix: Match the Tool to the Actual Number of Concatenations
- For a small, fixed number of concatenations known at compile time (a handful of fields joined into one string), plain
+or interpolated strings ($"{a} {b}") are simpler AND often faster – the compiler already optimizes chained concatenation into one String.Concat call. - Reserve StringBuilder specifically for LOOPS with an unknown or large number of iterations (building a report line by line, joining a big collection) – that’s the actual scenario where avoiding repeated intermediate allocations pays off.
- When performance genuinely matters, measure both approaches for YOUR specific case with a tool like BenchmarkDotNet rather than assuming – ‘StringBuilder is always faster’ is a rule of thumb with a real, measurable exception at small scale.
⚠️ The Actual Rule of Thumb
- Concatenating a small, fixed handful of strings once: plain
+or string interpolation. Building a string across a loop with many iterations, or an unknown number of pieces: StringBuilder. The deciding factor is the NUMBER of concatenations, not a blanket preference for one approach.
StringBuilder’s advantage was never automatic — it comes from avoiding repeated work across many iterations, and applying it where there’s barely any repetition just adds overhead with nothing to offset it.
