Como modificar o conteúdo de uma cadeia de caracteres em C#

Artigo
05/09/2023

Este artigo demonstra várias técnicas para produzir um string modificando um string existente. Todas as técnicas demonstradas retornam o resultado das modificações como um novo objeto string. Para demonstrar que as cadeias de caracteres originais e modificadas são instâncias distintas, os exemplos armazenam o resultado em uma nova variável. Você pode examinar o original string e o string novo e modificado ao executar cada exemplo.

Observação

Os exemplos de C# neste artigo são executados no executador de código embutido Try.NET e no playground. Clique no botão Executar para executar um exemplo em uma janela interativa. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente. O código modificado será executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todos as mensagens de erro do compilador C#.

Há várias técnicas demonstradas neste artigo. Você pode substituir o texto existente. Você pode procurar padrões e substituir o texto correspondente com outro texto. Você pode tratar uma cadeia de caracteres como uma sequência de caracteres. Você também pode usar métodos de conveniência que removem o espaço em branco. Escolha as técnicas que mais se aproximam do seu cenário.

Substituir texto

O código a seguir cria uma nova cadeia de caracteres, substituindo o texto existente por um substituto.

string source = "The mountains are behind the clouds today.";

// Replace one substring with another with String.Replace.
// Only exact matches are supported.
var replacement = source.Replace("mountains", "peaks");
Console.WriteLine($"The source string is <{source}>");
Console.WriteLine($"The updated string is <{replacement}>");

O código anterior demonstra essa propriedade immutable de cadeias de caracteres. Você pode ver no exemplo anterior que a cadeia de caracteres original, source, não é modificada. O método String.Replace cria uma nova string contendo as modificações.

O método Replace pode substituir cadeias de caracteres ou caracteres únicos. Em ambos os casos, todas as ocorrências do texto pesquisado são substituídas. O exemplo a seguir substitui todos os caracteres ' ' com '_':

string source = "The mountains are behind the clouds today.";

// Replace all occurrences of one char with another.
var replacement = source.Replace(' ', '_');
Console.WriteLine(source);
Console.WriteLine(replacement);

A cadeia de caracteres de origem não é alterada e uma nova cadeia de caracteres é retornada com a substituição.

Cortar espaço em branco

Você pode usar os métodos String.Trim, String.TrimStart e String.TrimEnd para remover espaços em branco à esquerda ou à direita. O código a seguir mostra um exemplo de cada um desses casos. A cadeia de caracteres de origem não é alterada; esses métodos retornam uma nova cadeia de caracteres com o conteúdo modificado.

// Remove trailing and leading white space.
string source = "    I'm wider than I need to be.      ";
// Store the results in a new string variable.
var trimmedResult = source.Trim();
var trimLeading = source.TrimStart();
var trimTrailing = source.TrimEnd();
Console.WriteLine($"<{source}>");
Console.WriteLine($"<{trimmedResult}>");
Console.WriteLine($"<{trimLeading}>");
Console.WriteLine($"<{trimTrailing}>");

Remover texto

Você pode remover texto de uma cadeia de caracteres usando o método String.Remove. Esse método remove um número de caracteres começando em um índice específico. O exemplo a seguir mostra como usar String.IndexOf seguido por Remove para remover texto de uma cadeia de caracteres:

string source = "Many mountains are behind many clouds today.";
// Remove a substring from the middle of the string.
string toRemove = "many ";
string result = string.Empty;
int i = source.IndexOf(toRemove);
if (i >= 0)
{
    result= source.Remove(i, toRemove.Length);
}
Console.WriteLine(source);
Console.WriteLine(result);

Substituir padrões correspondentes

Você pode usar expressões regulares para substituir padrões correspondentes de texto com um novo texto, possivelmente definido por um padrão. O exemplo a seguir usa a classe System.Text.RegularExpressions.Regex para localizar um padrão em uma cadeia de caracteres de origem e substituí-lo pela capitalização correta. O método Regex.Replace(String, String, MatchEvaluator, RegexOptions) usa uma função que fornece a lógica de substituição como um de seus argumentos. Neste exemplo, essa função LocalReplaceMatchCase é uma função local declarada dentro do método de exemplo. LocalReplaceMatchCase usa a classe System.Text.StringBuilder para criar a cadeia de caracteres de substituição com a capitalização correta.

Expressões regulares são mais úteis para localizar e substituir texto que segue um padrão, em vez de texto conhecido. Saiba mais em Como pesquisar cadeias de caracteres. O padrão de pesquisa "the\s" procura a palavra "the" seguida por um caractere de espaço em branco. Essa parte do padrão garante que isso não corresponda a "there" na cadeia de caracteres de origem. Para obter mais informações sobre elementos de linguagem de expressão regular, consulte Linguagem de expressão regular – referência rápida.

string source = "The mountains are still there behind the clouds today.";

// Use Regex.Replace for more flexibility.
// Replace "the" or "The" with "many" or "Many".
// using System.Text.RegularExpressions
string replaceWith = "many ";
source = System.Text.RegularExpressions.Regex.Replace(source, "the\\s", LocalReplaceMatchCase,
    System.Text.RegularExpressions.RegexOptions.IgnoreCase);
Console.WriteLine(source);

string LocalReplaceMatchCase(System.Text.RegularExpressions.Match matchExpression)
{
    // Test whether the match is capitalized
    if (Char.IsUpper(matchExpression.Value[0]))
    {
        // Capitalize the replacement string
        System.Text.StringBuilder replacementBuilder = new System.Text.StringBuilder(replaceWith);
        replacementBuilder[0] = Char.ToUpper(replacementBuilder[0]);
        return replacementBuilder.ToString();
    }
    else
    {
        return replaceWith;
    }
}

O método StringBuilder.ToString retorna uma cadeia de caracteres imutável com o conteúdo no objeto StringBuilder.

Modificar caracteres individuais

Você pode produzir uma matriz de caracteres de uma cadeia de caracteres, modificar o conteúdo da matriz e, em seguida, criar uma nova cadeia de caracteres com base no conteúdo modificado da matriz.

O exemplo a seguir mostra como substituir um conjunto de caracteres em uma cadeia de caracteres. Primeiro, ele usa o método String.ToCharArray() para criar uma matriz de caracteres. Ele usa o método IndexOf para encontrar o índice inicial da palavra "fox". Os próximos três caracteres são substituídos por uma palavra diferente. Por fim, uma nova cadeia de caracteres é construída com a matriz de caracteres atualizada.

string phrase = "The quick brown fox jumps over the fence";
Console.WriteLine(phrase);

char[] phraseAsChars = phrase.ToCharArray();
int animalIndex = phrase.IndexOf("fox");
if (animalIndex != -1)
{
    phraseAsChars[animalIndex++] = 'c';
    phraseAsChars[animalIndex++] = 'a';
    phraseAsChars[animalIndex] = 't';
}

string updatedPhrase = new string(phraseAsChars);
Console.WriteLine(updatedPhrase);

Compilar programaticamente o conteúdo de cadeia de caracteres

Como as cadeias de caracteres são imutáveis, todos os exemplos anteriores criam cadeias de caracteres temporárias ou matrizes de caracteres. Em cenários de alto desempenho, pode ser desejável evitar essas alocações de heap. O .NET Core fornece um método String.Create que permite preencher programaticamente o conteúdo de caracteres de uma cadeia de caracteres por meio de um retorno de chamada, evitando as alocações de cadeias de caracteres temporárias intermediárias.

// constructing a string from a char array, prefix it with some additional characters
char[] chars = { 'a', 'b', 'c', 'd', '\0' };
int length = chars.Length + 2;
string result = string.Create(length, chars, (Span<char> strContent, char[] charArray) =>
{
    strContent[0] = '0';
    strContent[1] = '1';
    for (int i = 0; i < charArray.Length; i++)
    {
        strContent[i + 2] = charArray[i];
    }
});

Console.WriteLine(result);

Você pode modificar uma cadeia de caracteres em um bloco fixo com código não seguro, mas é altamente desaconselhável modificar o conteúdo da cadeia de caracteres depois que uma cadeia de caracteres é criada. Fazer isso pode quebrar as coisas de maneiras imprevisíveis. Por exemplo, se alguém internalizar uma cadeia de caracteres com o mesmo conteúdo que o seu, ele receberá a sua cópia e não esperará que você esteja modificando sua cadeia de caracteres.