Strings & search benchmarks

BENCHMARKS · STRINGS & SEARCH

Building text and finding characters — the everyday hot paths. Suite and raw reports: github.com/gdhami-net/dotnet-benchmarks.

Intel Core Ultra 9 285HX · Windows 11 · BenchmarkDotNet 0.15.8 · SDK 10.0.201 · 2026-08-22 · single run — not yet median-of-N · bars/tables: mean time, lower is better

BuildReport

Build a 1,000-line CSV report four ways — including the naive += loop everyone writes first.

TAKEAWAY Never build strings with += in a loop - it recopies everything each pass. StringBuilder for incremental building; Join/interpolation is fine for one-shot projections.
In this run: StringBuilder_append is fastest (it is the baseline).

RESULTS

method	net9.0	net10.0	ratio	allocated	Δ net10.0
StringBuilder_append baseline	36.4 µs ±1.0 µs	32.4 µs ±1.4 µs	1.00×	114.5 KB	-11%
Naive_plus_equals	2.66 ms ±513.7 µs	2.77 ms ±643.8 µs	85.47×	23.83 MB	+4%
Join_interpolation	54.9 µs ±598 ns	48.6 µs ±629 ns	1.50×	119.0 KB	-11%

RATIO VS BASELINE · net10.0

StringBuilder_append

1.00×

Naive_plus_equals

85.47×

Join_interpolation

1.50×

THE LEDGER · SAME WORKLOAD ACROSS RELEASES (LOG)

StringBuilder_appendNaive_plus_equalsJoin_interpolation

THE CODE BEING MEASURED

StringBuilder_append — what this measures

StringBuilder with chained Appends — the textbook answer.

[Benchmark (Baseline)]
public string StringBuilder_append()
{
    var sb = new StringBuilder();
    foreach (var o in _orders)
        sb.Append(o.Id).Append(';').Append(o.Customer).Append(';').Append(o.Total).AppendLine();
    return sb.ToString();
}

Naive_plus_equals — what this measures

Naive string += in a loop — quadratic: every iteration copies everything so far.

[Benchmark]
public string Naive_plus_equals()
{
    var s = "";
    foreach (var o in _orders)
        s += o.Id + ";" + o.Customer + ";" + o.Total + "\n";
    return s;
}

Join_interpolation — what this measures

string.Join over an interpolated LINQ projection.

[Benchmark]
public string Join_interpolation() =>
    string.Join('\n', _orders.Select(o => $"
{o.Id}

FindDelimiters

Find delimiter characters in a haystack: classic IndexOfAny vs .NET 8+ SearchValues vs a manual loop.

TAKEAWAY IndexOfAny with a small char set is already vectorized in modern .NET - SearchValues matches it here and pulls ahead as the set grows or matches get rarer. The hand-written loop is the only clear loser; either vectorized API halves it.
In this run: IndexOfAny_chars is fastest (it is the baseline).

RESULTS — 1000

method	net9.0	net10.0	ratio	allocated	Δ net10.0
IndexOfAny_chars baseline	187 ns ±3 ns	178 ns ±2 ns	1.00×	—	-5%
SearchValues_chars	187 ns ±1 ns	183 ns ±2 ns	1.03×	—	-2%
Manual_loop	281 ns ±4 ns	266 ns ±2 ns	1.50×	—	-6%

RATIO VS BASELINE — 1000 · net10.0

IndexOfAny_chars

1.00×

SearchValues_chars

1.03×

Manual_loop

1.50×

RESULTS — 100000

method	net9.0	net10.0	ratio	allocated	Δ net10.0
IndexOfAny_chars baseline	17.4 µs ±577 ns	16.4 µs ±238 ns	1.00×	—	-5%
SearchValues_chars	17.6 µs ±261 ns	17.4 µs ±76 ns	1.06×	—	-1%
Manual_loop	33.9 µs ±327 ns	33.2 µs ±325 ns	2.02×	—	-2%

RATIO VS BASELINE — 100000 · net10.0

IndexOfAny_chars

1.00×

SearchValues_chars

1.06×

Manual_loop

2.02×

SCALING · net10.0 · MEAN TIME BY INPUT SIZE (LOG)

IndexOfAny_charsSearchValues_charsManual_loop

THE LEDGER · SAME WORKLOAD ACROSS RELEASES (LOG)

IndexOfAny_charsSearchValues_charsManual_loop

THE CODE BEING MEASURED

IndexOfAny_chars — what this measures

string.IndexOfAny with a char array — the pre-.NET 8 idiom.

[Benchmark (Baseline)]
public int IndexOfAny_chars()
{
    var count = 0;
    var span = _haystack.AsSpan();
    int i;
    while ((i = span.IndexOfAny(DelimiterChars)) >= 0)
    {
        count++;
        span = span[(i + 1)..];
    }
    return count;
}

SearchValues_chars — what this measures

SearchValues (.NET 8+): precomputed, vectorized set search.

[Benchmark]
public int SearchValues_chars()
{
    var count = 0;
    var span = _haystack.AsSpan();
    int i;
    while ((i = span.IndexOfAny(DelimiterSearch)) >= 0)
    {
        count++;
        span = span[(i + 1)..];
    }
    return count;
}

Manual_loop — what this measures

A hand-written character loop — what the "I'll just write it myself" instinct produces.

[Benchmark]
public int Manual_loop()
{
    var count = 0;
    foreach (var c in _haystack)
        if (c is ';' or ',' or '\t' or '|') count++;
    return count;
}

speed vs allocation

Fast is one axis. What it costs the GC is the other.

StringBuilder_appendNaive_plus_equalsJoin_interpolationIndexOfAny_charsSearchValues_charsManual_loop