How do strings work in C#?

Question

Accepted Answer

In C#, **`string`** is an immutable reference type representing text. Strings support interpolation, a rich method library, and — importantly for performance — `StringBuilder` for efficient repeated modification.

## String interpolation and creation

```csharp
string name = "Ann";
int age = 30;

// string interpolation ($) — embed expressions directly
string msg = $"Hello {name}, you are {age} years old";
string formatted = $"Price: {price:C2}";    // {value:format} — C2 = currency, 2 decimals

// verbatim strings (@) — no escaping, multi-line
string path = @"C:\Users\Ann";               // backslashes literal, no \ needed
string multi = """
    Raw string literal
    preserves formatting (C# 11)
    """;
```

**String interpolation** (`$"..."`) is the modern, readable way to build strings with embedded values and format specifiers. Verbatim (`@`) strings disable escaping (great for paths/regex), and raw string literals (`"""`) handle multi-line text.

## Strings are immutable

```csharp
string s = "Hello";
s.ToUpper();        // returns a NEW string "HELLO"; s is unchanged
s = s + " World";    // creates a NEW string; the old "Hello" is discarded
```

Every operation that "modifies" a string actually creates a **new** string (immutability). This is safe but has a performance cost for repeated modification.

## StringBuilder for efficient building

```csharp
// ❌ string concatenation in a loop — creates a new string each iteration (slow, O(n²))
string result = "";
for (int i = 0; i < 10000; i++) result += i;

// ✅ StringBuilder mutates a buffer — efficient (O(n))
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++) sb.Append(i);
string final = sb.ToString();
```

For building strings in loops, **`StringBuilder`** avoids creating many intermediate strings — a key performance practice.

## Common string methods

```csharp
s.Length; s.ToUpper(); s.Trim(); s.Substring(0, 5);
s.Contains("x"); s.IndexOf("x"); s.Replace("a", "b");
s.Split(','); string.Join(",", items);
string.IsNullOrEmpty(s); string.IsNullOrWhiteSpace(s);
```

## Why it matters

String manipulation is pervasive in programming (building output, processing input, formatting data), so understanding C# strings is essential everyday knowledge.

The modern features matter for productivity: **string interpolation** (`$"..."`) is the clean, readable way to build strings with embedded values and formatting, and verbatim/raw string literals handle paths and multi-line text elegantly.

Critically, understanding that **strings are immutable** (every "modification" creates a new string) explains a key performance consideration: naive **string concatenation in loops** is wasteful (O(n²), creating many intermediate strings), and knowing to use **`StringBuilder`** for repeated modification (which mutates an internal buffer efficiently) is an important practical optimization that comes directly from understanding immutability.

Knowing the rich string method library (search, replace, split/join, formatting), the modern interpolation syntax, and the immutability-driven StringBuilder practice is core knowledge for the constant string work that programming involves — fluency here, especially the interpolation convenience and the StringBuilder performance fix, is fundamental to writing clean, efficient C#.