Strings, StringBuilder and Span<T>

Strings are immutable

A string never changes after it is created. ToUpper, Replace, Trim and Substring all return a new string and leave the original alone. Calling one without using its result does nothing.

That also explains the cost of building text with += in a loop: every step copies everything so far into a new string, so building a string of n pieces copies on the order of n² characters. StringBuilder keeps a growable buffer and appends in place; call ToString() once at the end. For a handful of pieces, plain concatenation or interpolation is fine and clearer.

Comparing strings

There are two families of comparison:

• Ordinal compares the UTF-16 code units. It is fast, predictable, and the right choice for identifiers, keys, file names, protocol values: anything a machine reads.
• Culture-aware follows the linguistic rules of a culture. It is right for sorting text shown to people, and wrong almost everywhere else, because the result depends on the culture the code runs under.

The famous trap is Turkish, where lowercase i upper-cases to a dotted İ and uppercase I lower-cases to a dotless ı:

1using System.Globalization;2using System.Text;3 4public static class Solution5{6    public static string Describe()7    {8        string s = "hello";9        s.ToUpper();                                   // result thrown away10        string upper = s.ToUpper();11 12        var tr = new CultureInfo("tr-TR");13        string turkish = "title".ToUpper(tr);14        string invariant = "title".ToUpperInvariant();15        bool ordinalIgnore = string.Equals("FILE", "file", StringComparison.OrdinalIgnoreCase);16        bool trIgnore = string.Compare("TITLE", "title", tr, CompareOptions.IgnoreCase) == 0;17 18        var sb = new StringBuilder();19        for (int i = 0; i < 3; i++) sb.Append(i).Append(';');20        sb.Length--;                                   // drop the last separator21 22        return $"s={s} upper={upper} | tr upper={turkish} invariant upper={invariant} | " +23               $"OrdinalIgnoreCase FILE/file={ordinalIgnore} tr IgnoreCase TITLE/title={trIgnore} | sb={sb}";24    }25}

s.ToUpper() on its own changed nothing. Under the Turkish culture, "title" upper-cases to TİTLE, and a culture-aware case-insensitive comparison says TITLE and title are different words. Code that checks if (command.ToUpper() == "TITLE") breaks for Turkish users. Say what you mean: string.Equals(a, b, StringComparison.OrdinalIgnoreCase), ToUpperInvariant(), and StringComparer.Ordinal for dictionaries and sorting.

Span<T>: a window onto memory

Span<T> is a view of a contiguous region (part of an array, a stackalloc buffer, native memory) as a pointer plus a length. Slicing a span creates another view; nothing is copied. Writing through a span writes into the memory underneath. ReadOnlySpan<char> does the same for strings, so parsing code can pick out pieces of a string without allocating a Substring for each, and APIs such as int.Parse accept the slice directly.

1public static class Solution2{3    public static string Describe()4    {5        int[] numbers = { 1, 2, 3, 4, 5 };6        Span<int> middle = numbers.AsSpan(1, 3);    // a view of elements 1..3, no copy7        middle[0] = 99;8        middle.Reverse();9 10        string date = "2024-06-15";11        ReadOnlySpan<char> span = date;12        int dash = span.IndexOf('-');13        int year = int.Parse(span.Slice(0, dash));      // parses "2024" without a Substring14        ReadOnlySpan<char> rest = span.Slice(dash + 1);  // "06-15", still the same memory15        int month = int.Parse(rest.Slice(0, rest.IndexOf('-')));16 17        Span<char> buffer = stackalloc char[5];18        "abcde".AsSpan().CopyTo(buffer);19        buffer[0] = 'X';20 21        return $"array now {string.Join(",", numbers)} | year={year} month={month} rest={rest.ToString()} | buffer={buffer.ToString()}";22    }23}

The span covered elements 1 to 3 of the array; writing 99 and reversing the span rearranged the array itself. The year and month were parsed straight from slices of the string, and stackalloc gave a buffer on the stack that needs no garbage collection.

Span<T> is a ref struct: it may only live on the stack. The compiler forbids storing it in a field of a class, boxing it, capturing it in a lambda, or keeping it across an await. When you need a slice that can live on the heap, use Memory<T> and take .Span when you work with it.

Common mistakes

• Ignoring the result of a string method. s.Trim(); alone is a no-op, as s.ToUpper() showed above.
• += in a loop over many pieces. Quadratic copying; use StringBuilder or string.Join.
• Culture-sensitive comparison for machine data. ToUpper(), ToLower() and CompareTo use the current culture; prefer the Invariant and Ordinal variants for keys and protocol values.
• does not compile: the indexer is read-only. Copy the characters into a (or a buffer), edit them through a , and make one new string at the end, as the exercise does.