Como as strings funcionam em C#?

Question

Accepted Answer

Em C#, **`string`** é um tipo de referência imutável que representa texto. As strings suportam interpolação, uma biblioteca de métodos rica, e — importante para desempenho — `StringBuilder` para modificação repetida eficiente.

## Interpolação e criação de strings

```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)
    """;
```

**Interpolação de strings** (`$"..."`) é a forma moderna e legível de construir strings com valores incorporados e especificadores de formato. Strings entre aspas (`@`) desabilitam escapes (ótimo para caminhos/regex), e literais de strings brutas (`"""`) lidam com texto de múltiplas linhas.

## As strings são imutáveis

```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
```

Cada operação que "modifica" uma string na verdade cria uma **nova** string (imutabilidade). Isso é seguro, mas tem um custo de desempenho para modificação repetida.

## StringBuilder para construção eficiente

```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();
```

Ao construir strings em loops, **`StringBuilder`** evita criar muitas strings intermediárias — uma prática de desempenho importante.

## Métodos de string comuns

```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);
```

## Por que isso importa

A manipulação de strings é generalizada na programação (construir saída, processar entrada, formatar dados), então entender strings em C# é conhecimento essencial do dia a dia.

Os recursos modernos importam para produtividade: **interpolação de strings** (`$"..."`) é a forma limpa e legível de construir strings com valores incorporados e formatação, e strings entre aspas/literais brutos lidam elegantemente com caminhos e texto de múltiplas linhas.

Criticamente, entender que **as strings são imutáveis** (cada "modificação" cria uma nova string) explica uma consideração de desempenho importante: **concatenação ingênua de strings em loops** é desperdício (O(n²), cria muitas strings intermediárias), e saber usar **`StringBuilder`** para modificação repetida (que muta um buffer interno eficientemente) é uma otimização prática importante que vem diretamente de entender imutabilidade.

Conhecer a biblioteca de métodos de string rica (pesquisar, substituir, dividir/juntar, formatação), a sintaxe de interpolação moderna, e a prática StringBuilder impulsionada por imutabilidade é conhecimento essencial para o trabalho constante com strings que a programação envolve — fluência aqui, especialmente a conveniência de interpolação e a correção de desempenho StringBuilder, é fundamental para escrever C# limpo e eficiente.