¿Cómo funcionan las cadenas de texto en C#?

Question

Accepted Answer

En C#, **`string`** es un tipo de referencia inmutable que representa texto. Las cadenas de texto admiten interpolación, una rica biblioteca de métodos y — lo que es importante para el rendimiento — `StringBuilder` para la modificación eficiente y repetida.

## Interpolación de cadenas y creación

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

**La interpolación de cadenas** (`$"..."`) es la forma moderna y legible de construir cadenas con valores incrustados y especificadores de formato. Las cadenas textuales (`@`) desactivan el escape (excelente para rutas/regex), y los literales de cadena sin procesar (`"""`) manejan texto multilínea.

## Las cadenas son inmutables

```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 operación que "modifica" una cadena en realidad crea una **nueva** cadena (inmutabilidad). Esto es seguro pero tiene un costo de rendimiento para la modificación repetida.

## StringBuilder para construcción 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();
```

Para construir cadenas en bucles, **`StringBuilder`** evita crear muchas cadenas intermedias — una práctica clave de rendimiento.

## Métodos comunes de cadenas

```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 qué es importante

La manipulación de cadenas es omnipresente en programación (construir salida, procesar entrada, formatear datos), por lo que entender las cadenas de C# es conocimiento esencial del día a día.

Las características modernas importan para la productividad: **la interpolación de cadenas** (`$"..."`) es la forma limpia y legible de construir cadenas con valores incrustados y formato, y los literales de cadena textuales/sin procesar manejan rutas y texto multilínea elegantemente.

Críticamente, entender que **las cadenas son inmutables** (cada "modificación" crea una nueva cadena) explica una consideración clave de rendimiento: la **concatenación ingenua de cadenas en bucles** es derrochadora (O(n²), creando muchas cadenas intermedias), y saber usar **`StringBuilder`** para la modificación repetida (que muta un búfer interno eficientemente) es una optimización práctica importante que surge directamente de entender la inmutabilidad.

Conocer la rica biblioteca de métodos de cadenas (búsqueda, reemplazo, división/unión, formato), la sintaxis moderna de interpolación y la práctica de StringBuilder impulsada por inmutabilidad es conocimiento fundamental para el trabajo constante con cadenas que implica la programación — la fluidez aquí, especialmente la conveniencia de la interpolación y la corrección de rendimiento de StringBuilder, es fundamental para escribir C# limpio y eficiente.