String en C#: Length, comparar, caracteres de escape, strings literales y multilínea

Un string en C# es una secuencia de caracteres UTF-16 (valores char). Es un tipo de referencia, pero se comporta como un valor en lo que importa: es inmutable, y == compara el texto en lugar de la identidad del objeto. string es la palabra clave de C# para el tipo .NET System.String; los dos son intercambiables.

using System;

class Program
{
    static void Main()
    {
        string city = "Porto";
        string empty = "";
        string repeated = new string('*', 5);
        char[] letters = { 'h', 'i' };
        string fromChars = new string(letters);

        Console.WriteLine(city);
        Console.WriteLine(city.Length);
        Console.WriteLine(empty.Length);
        Console.WriteLine(repeated);
        Console.WriteLine(fromChars);
        Console.WriteLine(city + " has " + city.Length + " letters");
    }
}

Salida:

Porto
5
0
*****
hi
Porto has 5 letters

Los strings son inmutables

Ningún método cambia un string en el sitio. ToUpper, Replace, Trim y todos los demás métodos devuelven un string nuevo y dejan el original intacto. Olvidarse de usar el valor devuelto es un bug de strings muy común:

using System;

class Program
{
    static void Main()
    {
        string name = "  maya  ";

        name.Trim();          // result discarded: name is unchanged
        name.ToUpper();       // same
        Console.WriteLine($"[{name}]");

        name = name.Trim().ToUpper();   // assign the new string
        Console.WriteLine($"[{name}]");

        string original = "tea";
        string copy = original;
        copy += " and cake";   // creates a new string; original is not affected
        Console.WriteLine(original);
        Console.WriteLine(copy);
    }
}

Salida:

[  maya  ]
[MAYA]
tea
tea and cake

La inmutabilidad hace que los strings puedan compartirse sin riesgo entre hilos y usarse como claves de diccionario. El coste es que construir un string pieza a pieza en un bucle crea un string nuevo en cada paso; para eso, usa StringBuilder.

Length e índices

Length es una propiedad (sin paréntesis). El indexador s[i] devuelve el char de la posición i, contando desde 0, y es de solo lectura:

using System;

class Program
{
    static void Main()
    {
        string code = "AB-2931";

        Console.WriteLine(code.Length);          // 7
        Console.WriteLine(code[0]);              // A
        Console.WriteLine(code[code.Length - 1]); // last character: 1

        // code[0] = 'X';   // error CS0200: the indexer is read-only

        try
        {
            char c = code[7];                    // valid indexes are 0..6
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("IndexOutOfRangeException");
        }

        char[] chars = code.ToCharArray();       // to modify, copy into an array
        chars[0] = 'X';
        Console.WriteLine(new string(chars));
    }
}

Salida:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 y posteriores también aceptan un índice desde el final: code[^1] es el último carácter, igual que code[code.Length - 1]. Para tomar varios caracteres a la vez, consulta substring.

Length cuenta unidades de código UTF-16, no lo que un lector ve como caracteres. La mayoría de las letras de la mayoría de los idiomas ocupan una unidad, pero los emoji y algunas escrituras poco comunes usan dos (un par suplente), así que "👍".Length es 2.

Comparar strings

== y != comparan los caracteres, distinguiendo mayúsculas y minúsculas. Para cualquier otra cosa, pasa un valor StringComparison que diga cómo comparar:

using System;

class Program
{
    static void Main()
    {
        string a = "Report.PDF";
        string b = "report.pdf";

        Console.WriteLine(a == b);                                   // False
        Console.WriteLine(a.Equals(b));                              // False
        Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True
        Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));         // True

        // Ordering: negative, zero or positive
        int order = string.Compare("apple", "banana", StringComparison.Ordinal);
        Console.WriteLine(order < 0 ? "apple first" : "banana first");

        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.Ordinal) < 0);           // uppercase sorts first
        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.OrdinalIgnoreCase) < 0); // False

        string missing = null;
        Console.WriteLine(missing == "x");                           // False, no exception
        Console.WriteLine(string.Equals(missing, null));             // True
    }
}

Salida:

False
False
True
True
apple first
True
False
False
True

Qué comparación usar:

• Ordinal compara los códigos numéricos de los caracteres. Es rápida, predecible e igual en todas las máquinas. Úsala para identificadores, nombres de archivo, claves, valores de protocolo y todo lo que no se muestre a una persona.
• OrdinalIgnoreCase es lo mismo, sin distinguir mayúsculas. Es la opción correcta para comprobaciones que no distinguen mayúsculas, como las extensiones de archivo o las cabeceras HTTP.
• CurrentCulture (y CurrentCultureIgnoreCase) sigue las reglas del idioma del usuario, así que ordena las palabras como lo haría un diccionario de ese idioma. Úsala para ordenar listas que se muestran a los usuarios.
• InvariantCulture usa reglas que tienen en cuenta la cultura pero no dependen de la configuración de idioma del usuario. Aun así depende de la biblioteca de globalización: el .NET moderno usa ICU, .NET Framework usa NLS de Windows, y los dos pueden ordenar algunos strings de forma distinta.

string.Compare(a, b) y a.CompareTo(b) sin un StringComparison usan la cultura actual, lo que hace que sus resultados varíen entre máquinas. Evita comparar con a.ToLower() == b.ToLower(): reserva dos strings nuevos y da respuestas incorrectas en algunas culturas (la i con y sin punto del turco es el caso clásico).

Llamar a a.Equals(b) cuando a es null lanza una NullReferenceException, mientras que a == b y el string.Equals(a, b) static manejan null sin problemas.

Caracteres de escape

Dentro de un literal de string normal, una barra invertida inicia una secuencia de escape:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Name:\tAna\nCity:\tPorto");
        Console.WriteLine("She said \"hi\"");
        Console.WriteLine("C:\\temp\\report.txt");
        Console.WriteLine("caf\u0065 = cafe");
        Console.WriteLine('\'' + " is a quote char");
    }
}

Salida:

Name:	Ana
City:	Porto
She said "hi"
C:\temp\report.txt
cafe = cafe
' is a quote char

Una secuencia no reconocida como "\d" es un error de compilación (CS1009, secuencia de escape no reconocida), que es lo que ocurre cuando una ruta de Windows o una expresión regular se escribe como un string normal.

Strings literales (verbatim) y strings multilínea

Poner el prefijo @ a un literal lo hace literal (verbatim): las barras invertidas son caracteres normales, y el string puede ocupar varias líneas. El único escape que queda es "", que produce una comilla doble.

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Users\ana\Documents\notes.txt";
        string pattern = @"\d{3}-\d{4}";
        string quote = @"He said ""ready"" and left.";

        string address = @"Rua das Flores 12
4050-262 Porto
Portugal";

        Console.WriteLine(path);
        Console.WriteLine(pattern);
        Console.WriteLine(quote);
        Console.WriteLine(address);

        string lines = "first line" + Environment.NewLine + "second line";
        Console.WriteLine(lines);
    }
}

Salida:

C:\Users\ana\Documents\notes.txt
\d{3}-\d{4}
He said "ready" and left.
Rua das Flores 12
4050-262 Porto
Portugal
first line
second line

Un string literal multilínea incluye todo lo que hay entre las comillas, incluida la indentación de las líneas de continuación, y por eso suelen escribirse pegados al margen como arriba. Los saltos de línea que contiene son los del archivo fuente, así que un archivo guardado con finales de línea de Windows produce \r\n.

C# 11 añadió los literales de string sin procesar, que resuelven los dos problemas. Empiezan y terminan con tres o más comillas dobles, no necesitan ningún escape y quitan la indentación que tengan las comillas de cierre:

// C# 11 and later
string json = """
    {
      "name": "Ana",
      "path": "C:\temp"
    }
    """;
// The 4 spaces before the closing """ are removed from every line.

Si el propio contenido contiene """, empieza y termina con cuatro comillas. Los literales sin procesar también se combinan con la interpolación ($"""..."""); consulta interpolación de strings.

Null, vacío y espacios en blanco

Una variable string puede ser null (ningún string), vacía ("", longitud 0) o contener solo espacios en blanco. Dos métodos auxiliares static comprueban estos casos sin arriesgarse a una NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "Ana" };

        foreach (string s in inputs)
        {
            string shown = s == null ? "null" : $"\"{s}\"";
            Console.WriteLine($"{shown,-7} empty: {string.IsNullOrEmpty(s),-5}  blank: {string.IsNullOrWhiteSpace(s)}");
        }

        Console.WriteLine(string.Empty == "");
    }
}

Salida:

null    empty: True   blank: True
""      empty: True   blank: True
"   "   empty: False  blank: True
"Ana"   empty: False  blank: False
True

Para validar la entrada del usuario, string.IsNullOrWhiteSpace es casi siempre el que quieres. string.Empty y "" son el mismo valor; cuál escribir es cuestión de estilo.

Recorrer los caracteres

Un string es enumerable, así que foreach visita cada char. El tipo char tiene métodos static para clasificar caracteres:

using System;

class Program
{
    static void Main()
    {
        string password = "Sunset2026!";
        int letters = 0, digits = 0, upper = 0, other = 0;

        foreach (char c in password)
        {
            if (char.IsLetter(c)) letters++;
            if (char.IsDigit(c)) digits++;
            if (char.IsUpper(c)) upper++;
            if (!char.IsLetterOrDigit(c)) other++;
        }

        Console.WriteLine($"letters={letters} digits={digits} upper={upper} symbols={other}");

        for (int i = password.Length - 1; i >= 0; i--)   // backwards with an index
        {
            Console.Write(password[i]);
        }
        Console.WriteLine();
    }
}

Salida:

letters=6 digits=4 upper=1 symbols=1
!6202tesnuS

Unir strings

+ concatena, y funciona con cualquier tipo al otro lado (llama a ToString()). Para combinar muchos valores, prefiere la interpolación o string.Join:

using System;

class Program
{
    static void Main()
    {
        string first = "Ana", last = "Silva";
        int age = 31;

        Console.WriteLine(first + " " + last + ", " + age);
        Console.WriteLine($"{first} {last}, {age}");
        Console.WriteLine(string.Concat(first, last));
        Console.WriteLine(string.Join(" | ", "tea", "coffee", "juice"));
        Console.WriteLine("Total: " + 2 + 3);    // "Total: 23"
        Console.WriteLine("Total: " + (2 + 3));  // "Total: 5"
    }
}

Salida:

Ana Silva, 31
Ana Silva, 31
AnaSilva
tea | coffee | juice
Total: 23
Total: 5

Las dos últimas líneas muestran una trampa de precedencia: + se evalúa de izquierda a derecha, así que en cuanto el lado izquierdo es un string, cada + siguiente es una concatenación. Pon entre paréntesis la aritmética que va dentro de una concatenación.