Every string method
you'll actually use,
with the result.

02 · Look before you touch

🔍 Inspect: length, characters and emptiness

The cheapest operations — and the ones that stop a NullReferenceException before it happens.

🛡️ Guarding inputs in .NET 8

public Customer Create(string name, string? nickname)
{
    ArgumentException.ThrowIfNullOrWhiteSpace(name);   // .NET 8

    var display = nickname?.Trim() ?? name.Trim();     // null-safe
    return new Customer(display);
}

💡 ArgumentException.ThrowIfNullOrEmpty arrived in .NET 7 and ThrowIfNullOrWhiteSpace in .NET 8. They throw ArgumentNullException for null and ArgumentException otherwise, with the parameter name filled in for you.

03 · Find things

🔎 Search: contains, starts with, index of

The fix is a habit, not a memory test: whenever a string method accepts a StringComparison, pass one. The .NET analyzers (CA1307, CA1309, CA1310) will flag the calls that don't.

04 · Equal or not?

⚖️ Compare: StringComparison explained

Two questions decide how strings should be compared: does case matter? and is this text for humans or for machines?

🗂️ Case-insensitive collections

Don't lowercase keys by hand — give the collection a comparer:

var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
    ["Content-Type"] = "application/json"
};
headers.ContainsKey("content-type");   // true

var tags = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "CSharp", "csharp" };
tags.Count;                               // 1

var distinct = names.Distinct(StringComparer.OrdinalIgnoreCase).ToList();

05 · Change it

🛠️ Transform: case, trim, pad, replace, cut

Every method here returns a new string.

🔗 A simple slug in C#

static string Slugify(string input)
{
    // split accented letters into letter + mark, then drop the marks
    var decomposed = input.Normalize(NormalizationForm.FormD);
    var sb = new StringBuilder(decomposed.Length);
    foreach (var c in decomposed)
        if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
            sb.Append(c);

    var ascii = sb.ToString().ToLowerInvariant();
    ascii = Regex.Replace(ascii, @"[^a-z0-9]+", "-");
    return ascii.Trim('-');
}

Slugify("Crème Brûlée: 10 Tips!");   // "creme-brulee-10-tips"

💡 Compare the output against the Slug Generator while you tune the rules.

06 · Many from one, one from many

🪓 Split, join and concatenate

07 · Build readable output

🧾 Formatting, interpolation and raw strings

Interpolated strings ($"...") are the modern default; since C# 10 they compile to efficient handlers rather than string.Format calls.

// verbatim: backslashes are literal, "" is a quote
var path = @"C:\logs\app.txt";

// raw string literal (C# 11): no escaping at all, indentation trimmed
var json = """
    { "name": "Ana", "tags": ["a", "b"] }
    """;

// interpolated raw string: $$ means {{ }} marks a hole, single { } stay literal
var body = $$"""
    { "id": {{orderId}} }
    """;

// culture-independent output for logs, files and APIs
var line = FormattableString.Invariant($"{price:F2}");
var same = string.Create(CultureInfo.InvariantCulture, $"{price:F2}");   // .NET 6+

08 · Performance

🏗️ StringBuilder and spans

Because strings are immutable, s += x in a loop copies the whole string every time — fine for five iterations, painful for five thousand. StringBuilder keeps one growable buffer.

var sb = new StringBuilder();
sb.AppendLine("id,name");
foreach (var c in customers)
    sb.Append(c.Id).Append(',').AppendLine(c.Name);

File.WriteAllText("customers.csv", sb.ToString());

🪶 Spans, briefly

ReadOnlySpan<char> is a view over part of a string without copying it. Most parsing APIs accept spans, so you can slice and parse without allocating substrings:

ReadOnlySpan<char> date = "2026-10-01";
int year  = int.Parse(date[..4]);      // 2026 — no substring allocated
int month = int.Parse(date[5..7]);    // 10

// .NET 8: SearchValues precomputes a fast lookup for IndexOfAny
static readonly SearchValues<char> Separators = SearchValues.Create(",;|");
int at = line.AsSpan().IndexOfAny(Separators);

💡 Reach for spans in hot paths — parsers, per-request middleware, tight loops. In ordinary business code, clear string methods are the better trade.

09 · Read before you ship

🪤 Gotchas that cause real bugs

1. 🧊 Forgetting strings are immutable

   input.Trim(); discards its result. Assign it: input = input.Trim();. The same applies to Replace, ToUpper, PadLeft — every transform.

2. 🇹🇷 Culture-sensitive case and comparison

   Under the Turkish culture, "file".ToUpper() returns "FİLE" (dotted capital İ), so a check like ext.ToUpper() == "FILE" fails on a Turkish server. Use ToUpperInvariant() or, better, StringComparison.OrdinalIgnoreCase for anything that isn't displayed to a person.

3. ⚖️ == vs Equals vs object

   On two string-typed values, == compares contents (ordinal, case-sensitive) and handles null. But if either side is typed as object, == compares references: object a = "x"; object b = new string('x', 1); gives a == b → false. And a.Equals(b) throws if a is null — static string.Equals(a, b, comparison) doesn't.

4. 🔎 Default comparisons differ between methods

   IndexOf(string), StartsWith(string), EndsWith(string), CompareTo and string.Compare(a, b) are culture-sensitive; ==, Equals, Contains and Replace are ordinal. Pass a StringComparison every time and you never have to remember which is which.

5. 🔁 Concatenation in loops

   result += line inside a loop is quadratic in the total length. Use StringBuilder, or collect into a list and call string.Join once.

6. 😀 Reversing and truncating by char

   new string(s.Reverse().ToArray()) and s[..10] operate on UTF-16 units and can split surrogate pairs, producing invalid text. For user-facing text, work with StringInfo text elements or s.EnumerateRunes().