Métodos de string em C#: Split, Replace, Contains, IndexOf, Trim, Join e mais

System.String tem dezenas de métodos. Esta página cobre os que fazem a maior parte do trabalho em código real, com as opções e as armadilhas que importam. Uma regra vale para todos eles: strings são imutáveis, então todo método retorna uma string nova (ou um valor) e deixa a original sem mudança. s.Trim(); sozinho em uma linha não faz nada; escreva s = s.Trim();.

Split

Split quebra uma string em um string[] em 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));
    }
}

Saída:

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

Repare em " blue": Split corta exatamente no separador e mantém os espaços. Duas opções cuidam das limpezas comuns:

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

Saída:

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

RemoveEmptyEntries descarta partes de tamanho zero, mas não partes que só têm espaços (" " sobreviveu acima). O .NET 5 adicionou StringSplitOptions.TrimEntries, e as duas podem ser combinadas: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) dá o resultado limpo em uma chamada. Passar null como separador divide em qualquer espaço em branco, que é a forma usual de dividir um texto em palavras.

Dividir por um único char (Split(',')) não precisa de array. As sobrecargas que recebem um char mais opções, ou uma única string, existem a partir do .NET Core 2.0; as formas com array usadas acima funcionam em qualquer lugar, inclusive no .NET Framework e na Unity.

Replace

Replace substitui todas as ocorrências de um caractere ou de uma 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+", " "));
    }
}

Saída:

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

A sobrecarga com um argumento StringComparison está disponível no .NET Core 2.0 em diante. No .NET Framework, a substituição sem diferenciar maiúsculas e minúsculas é feita com Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Substituir por "" é como você remove caracteres, e encadear várias chamadas a Replace não tem problema para poucas substituições.

Contains, IndexOf, StartsWith e EndsWith

Estes métodos buscam. Contains responde sim ou não; IndexOf e LastIndexOf retornam uma posição, ou -1 quando não há correspondência; StartsWith e EndsWith testam as pontas.

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://"));
    }
}

Saída:

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

Todos diferenciam maiúsculas de minúsculas por padrão. Contains(string, StringComparison) existe no .NET Core 2.1 em diante; a forma IndexOf(...) >= 0 funciona em todas as versões, e é por isso que você a vê em código mais antigo. IndexOfAny(new[] { ',', ';' }) encontra o primeiro de vários caracteres.

Uma observação sobre cultura: sem um StringComparison, StartsWith, EndsWith, IndexOf(string) e CompareTo usam regras que dependem da cultura, enquanto Contains, Replace e IndexOf(char) comparam de forma ordinal. Passar StringComparison.Ordinal ou OrdinalIgnoreCase explicitamente remove a ambiguidade, e os analisadores de código recomendam isso.

Trim, TrimStart e TrimEnd

Trim remove os espaços em branco (espaços, tabulações, quebras de linha) das duas pontas. TrimStart e TrimEnd removem de uma ponta só. Se receberem caracteres, eles removem esses caracteres no 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'));
    }
}

Saída:

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

Trim só mexe nas pontas; os espaços no meio da string são mantidos. TrimStart('0') em "000" retorna uma string vazia, então converta strings numéricas com int.Parse em vez de tirar os zeros à mão.

ToUpper e 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);
    }
}

Saída:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper e ToLower seguem a cultura atual, então em turco "i".ToUpper() é um İ maiúsculo com ponto, não I. Para identificadores, chaves e nomes de arquivo, use ToUpperInvariant e ToLowerInvariant. Para comparar, use um StringComparison em vez de converter maiúsculas e minúsculas (veja strings). Para colocar a inicial de cada palavra em maiúscula, existe CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), embora ele não mexa em palavras que já estão todas em maiúsculas.

PadLeft e PadRight

O preenchimento adiciona caracteres até a string chegar a uma largura total. É útil para saídas de largura fixa e para completar códigos com zeros:

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

Saída:

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

O alinhamento na interpolação ({name,-10}) faz o mesmo trabalho no próprio texto.

Join e Concat

string.Join coloca um separador entre os elementos de qualquer coleção. string.Concat junta sem 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);
    }
}

Saída:

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

Join é a forma certa de montar uma lista com delimitadores: não sobra separador no fim para remover, e ele monta o resultado em uma passada. Ele chama ToString() em cada elemento, então funciona com números e objetos também.

Reverse, Insert e Remove

Não existe um método string.Reverse que retorne uma string. As duas abordagens usuais:

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

Saída:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

word.Reverse() sozinho retorna um IEnumerable<char>, não uma string; imprimi-lo mostra o nome de um tipo. Os dois métodos invertem unidades de código UTF-16, o que quebra caracteres formados por duas unidades (a maioria dos emojis) e letras com acentos combinados.

Referência rápida