Métodos de string en C#: Split, Replace, Contains, IndexOf, Trim, Join y más

System.String tiene decenas de métodos. Esta página trata los que hacen la mayor parte del trabajo en el código real, con las opciones y las trampas que importan. Hay una regla que se aplica a todos: los strings son inmutables, así que cada método devuelve un string nuevo (o un valor) y deja el original sin cambios. s.Trim(); en su propia línea no hace nada; escribe s = s.Trim();.

Split

Split parte un string en un string[] en cada separador:

using System;

class Program
{
    static void Main()
    {
        string csv = "apple,banana,cherry";
        string[] fruits = csv.Split(',');
        Console.WriteLine(fruits.Length);
        foreach (string f in fruits) Console.WriteLine(f);

        // Several separator characters
        string messy = "red;green, blue|yellow";
        string[] colors = messy.Split(new[] { ';', ',', '|' });
        Console.WriteLine(string.Join("/", colors));

        // A separator longer than one character
        string log = "INFO -> started -> ready";
        string[] steps = log.Split(new[] { " -> " }, StringSplitOptions.None);
        Console.WriteLine(string.Join("/", steps));
    }
}

Salida:

3
apple
banana
cherry
red/green/ blue/yellow
INFO/started/ready

Fíjate en " blue": Split corta exactamente en el separador y conserva los espacios. Dos opciones se ocupan de las limpiezas habituales:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string tags = "c#, ,dotnet,,  linq ";

        string[] raw = tags.Split(',');
        Console.WriteLine(raw.Length);   // empty and blank parts included

        string[] noEmpty = tags.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
        Console.WriteLine(noEmpty.Length);

        string[] clean = tags.Split(',')
            .Select(t => t.Trim())
            .Where(t => t.Length > 0)
            .ToArray();
        Console.WriteLine(string.Join("|", clean));

        // Limit the number of parts: the last one keeps the rest
        string header = "Subject: Re: Meeting: Friday";
        string[] kv = header.Split(new[] { ':' }, 2);
        Console.WriteLine($"key=[{kv[0]}] value=[{kv[1].Trim()}]");

        string words = "one  two   three";
        Console.WriteLine(words.Split((char[])null, StringSplitOptions.RemoveEmptyEntries).Length); // split on any whitespace
    }
}

Salida:

5
4
c#|dotnet|linq
key=[Subject] value=[Re: Meeting: Friday]
3

RemoveEmptyEntries descarta las partes de longitud cero, pero no las que solo tienen espacios (" " sobrevivió arriba). .NET 5 añadió StringSplitOptions.TrimEntries, y las dos pueden combinarse: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) da el resultado limpio en una sola llamada. Pasar null como separador divide por cualquier espacio en blanco, que es la forma habitual de dividir un texto en palabras.

Dividir por un solo char (Split(',')) no necesita array. Las sobrecargas que reciben un char más opciones, o un solo string, existen desde .NET Core 2.0; las formas con array usadas arriba funcionan en todas partes, incluidos .NET Framework y Unity.

Replace

Replace sustituye todas las apariciones de un carácter o de un substring:

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string phone = "555-123-4567";
        Console.WriteLine(phone.Replace("-", ""));       // remove
        Console.WriteLine(phone.Replace('-', '.'));      // char overload

        string text = "Cats and cats and CATS";
        Console.WriteLine(text.Replace("cats", "dogs")); // case-sensitive
        Console.WriteLine(text.Replace("cats", "dogs", StringComparison.OrdinalIgnoreCase));

        // Only the first occurrence
        var first = new Regex("cats", RegexOptions.IgnoreCase);
        Console.WriteLine(first.Replace(text, "dogs", 1));

        // Collapse repeated spaces
        Console.WriteLine(Regex.Replace("too    many   spaces", @"\s+", " "));
    }
}

Salida:

5551234567
555.123.4567
Cats and dogs and CATS
dogs and dogs and dogs
dogs and cats and CATS
too many spaces

La sobrecarga con un argumento StringComparison está disponible en .NET Core 2.0 y posteriores. En .NET Framework, la sustitución sin distinguir mayúsculas se hace con Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Sustituir por "" es la forma de eliminar caracteres, y encadenar varias llamadas a Replace está bien para un puñado de sustituciones.

Contains, IndexOf, StartsWith y EndsWith

Estos métodos buscan. Contains responde sí o no; IndexOf y LastIndexOf devuelven una posición, o -1 cuando no hay coincidencia; StartsWith y EndsWith comprueban los extremos.

using System;

class Program
{
    static void Main()
    {
        string subject = "Invoice #4471 overdue: please pay";

        Console.WriteLine(subject.Contains("overdue"));                    // True
        Console.WriteLine(subject.Contains("OVERDUE"));                    // False: case-sensitive
        Console.WriteLine(subject.Contains("OVERDUE", StringComparison.OrdinalIgnoreCase));
        Console.WriteLine(subject.IndexOf("OVERDUE", StringComparison.OrdinalIgnoreCase) >= 0);

        Console.WriteLine(subject.IndexOf('#'));            // 8
        Console.WriteLine(subject.IndexOf("pay"));          // first "pay"
        Console.WriteLine(subject.LastIndexOf('e'));
        Console.WriteLine(subject.IndexOf("refund"));       // -1: not found
        Console.WriteLine(subject.IndexOf('e', 10));        // search from index 10

        string file = "photo.JPG";
        Console.WriteLine(file.EndsWith(".jpg"));           // False
        Console.WriteLine(file.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase));
        Console.WriteLine("https://coddy.tech".StartsWith("https://"));
    }
}

Salida:

True
False
True
True
8
30
28
-1
16
False
True
True

Todos distinguen mayúsculas y minúsculas por defecto. Contains(string, StringComparison) existe en .NET Core 2.1 y posteriores; la forma IndexOf(...) >= 0 funciona en todas las versiones, y por eso aparece en el código antiguo. IndexOfAny(new[] { ',', ';' }) encuentra el primero de varios caracteres.

Una nota sobre la cultura: sin un StringComparison, StartsWith, EndsWith, IndexOf(string) y CompareTo usan reglas que dependen de la cultura, mientras que Contains, Replace e IndexOf(char) comparan de forma ordinal. Pasar de forma explícita StringComparison.Ordinal u OrdinalIgnoreCase elimina la ambigüedad, y los analizadores de código lo recomiendan.

Trim, TrimStart y TrimEnd

Trim quita los espacios en blanco (espacios, tabuladores, saltos de línea) de los dos extremos. TrimStart y TrimEnd quitan de un solo extremo. Si les pasas caracteres, quitan esos en su lugar:

using System;

class Program
{
    static void Main()
    {
        string input = "  \t ana@example.com \n";
        Console.WriteLine($"[{input.Trim()}]");
        Console.WriteLine($"[{input.TrimStart()}]".Replace("\n", "\\n"));
        Console.WriteLine($"[{"  x  ".TrimEnd()}]");

        Console.WriteLine("***SALE***".Trim('*'));
        Console.WriteLine("007".TrimStart('0'));
        Console.WriteLine("path/to/dir///".TrimEnd('/'));
        Console.WriteLine("1,234.50 USD".TrimEnd(' ', 'U', 'S', 'D'));
    }
}

Salida:

[ana@example.com]
[ana@example.com \n]
[  x]
SALE
7
path/to/dir
1,234.50

Trim solo toca los extremos; los espacios de dentro del string se conservan. TrimStart('0') sobre "000" devuelve un string vacío, así que parsea los strings numéricos con int.Parse en lugar de quitar ceros a mano.

ToUpper y ToLower

using System;

class Program
{
    static void Main()
    {
        string name = "maya Lopez";
        Console.WriteLine(name.ToUpper());
        Console.WriteLine(name.ToLower());
        Console.WriteLine(name.ToUpperInvariant());

        // Capitalize the first letter
        string word = "coffee";
        string capital = char.ToUpper(word[0]) + word.Substring(1);
        Console.WriteLine(capital);
    }
}

Salida:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper y ToLower siguen la cultura actual, así que en turco "i".ToUpper() es una İ mayúscula con punto, no I. Para identificadores, claves y nombres de archivo, usa ToUpperInvariant y ToLowerInvariant. Para comparar, usa un StringComparison en lugar de convertir mayúsculas (consulta strings). Para poner en mayúscula la inicial de cada palabra existe CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), aunque deja como están las palabras que ya están enteras en mayúsculas.

PadLeft y PadRight

El relleno añade caracteres hasta que el string alcanza un ancho total. Es práctico para la salida de ancho fijo y para rellenar códigos con ceros:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("42".PadLeft(6, '0'));
        Console.WriteLine("[" + "Tea".PadRight(8) + "]");
        Console.WriteLine("[" + "Tea".PadLeft(8) + "]");
        Console.WriteLine("Too long already".PadLeft(4));   // never truncates

        string[] items = { "Espresso", "Latte", "Mocha" };
        decimal[] prices = { 2.40m, 3.60m, 3.95m };
        for (int i = 0; i < items.Length; i++)
        {
            Console.WriteLine(items[i].PadRight(10, '.') + prices[i].ToString("F2").PadLeft(6));
        }
    }
}

Salida:

000042
[Tea     ]
[     Tea]
Too long already
Espresso..  2.40
Latte.....  3.60
Mocha.....  3.95

La alineación de la interpolación ({name,-10}) hace el mismo trabajo en línea.

Join y Concat

string.Join pone un separador entre los elementos de cualquier colección. string.Concat une sin separador:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var guests = new List<string> { "Ana", "Ben", "Chloe" };
        Console.WriteLine(string.Join(", ", guests));
        Console.WriteLine(string.Join(" + ", new[] { 1, 2, 3 }));   // any type
        Console.WriteLine(string.Join(",", new string[0]) == "");    // empty input: empty string

        Console.WriteLine(string.Concat("2026", "-", "09"));
        Console.WriteLine(string.Concat(guests));

        // "A, B and C"
        string list = guests.Count > 1
            ? string.Join(", ", guests.GetRange(0, guests.Count - 1)) + " and " + guests[guests.Count - 1]
            : string.Join("", guests);
        Console.WriteLine(list);
    }
}

Salida:

Ana, Ben, Chloe
1 + 2 + 3
True
2026-09
AnaBenChloe
Ana, Ben and Chloe

Join es la forma correcta de construir una lista delimitada: no hay ningún separador final que quitar, y construye el resultado en una sola pasada. Llama a ToString() sobre cada elemento, así que también funciona con números y objetos.

Reverse, Insert y Remove

No hay ningún método string.Reverse que devuelva un string. Los dos enfoques habituales:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string word = "stressed";

        char[] chars = word.ToCharArray();
        Array.Reverse(chars);
        Console.WriteLine(new string(chars));

        Console.WriteLine(new string(word.Reverse().ToArray()));   // LINQ

        string racecar = "Racecar";
        string lower = racecar.ToLowerInvariant();
        Console.WriteLine(lower == new string(lower.Reverse().ToArray()));  // palindrome?

        Console.WriteLine("2026-09".Insert(4, "/Q3"));     // insert at an index
        Console.WriteLine("Hello, World".Remove(5));        // everything from index 5 removed
        Console.WriteLine("Hello, World".Remove(5, 2));     // 2 chars removed at 5
    }
}

Salida:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

word.Reverse() por sí solo devuelve un IEnumerable<char>, no un string; imprimirlo muestra el nombre de un tipo. Los dos métodos invierten unidades de código UTF-16, lo que rompe los caracteres formados por dos unidades (la mayoría de los emoji) y las letras con acentos combinados.

Referencia rápida