Come modificare il contenuto delle stringhe in C#

Articolo
02/13/2024

Questo articolo illustra diverse tecniche per produrre un oggetto string modificando un oggetto string esistente. Tutte le tecniche illustrate restituiscono il risultato delle modifiche come nuovo oggetto string. Per dimostrare che le stringhe originali e modificate sono istanze distinte, gli esempi archiviano il risultato in una nuova variabile. È possibile esaminare l’oggetto string originale e il nuovo oggetto string modificato durante l'esecuzione di ogni esempio.

Nota

Gli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.

Questo articolo illustra diverse tecniche. È possibile sostituire il testo esistente. È possibile cercare criteri e sostituire il testo corrispondente ai criteri con altro testo. È possibile considerare una stringa come sequenza di caratteri. È anche possibile usare metodi pratici per la rimozione degli spazi. Segliere le tecniche più adatte allo scenario in cui si opera.

Sostituisci testo

Il codice seguente crea una nuova stringa sostituendo il testo esistente con altro testo.

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

Il codice precedente illustra questa proprietà non modificabile delle stringhe. Come si vede nell'esempio precedente, la stringa originale, source, non viene modificata. Il metodo String.Replace crea un nuovo oggetto string contenente le modifiche.

Il metodo Replace può sostituire stringhe o caratteri singoli. In entrambi i casi, viene sostituita ogni ricorrenza del testo cercato. Nell'esempio seguente tutte le sequenze di caratteri ' ' vengono sostituite da '_':

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

La stringa di origine non viene modificata e viene restituita una nuova stringa con la sostituzione.

Eliminare gli spazi

È possibile usare i metodi String.Trim, String.TrimStart e String.TrimEnd per rimuovere tutti gli spazi iniziali o finali. Il codice seguente visualizza un esempio con ogni metodo. La stringa di origine resta invariata e i metodi restituiscono una nuova stringa con il contenuto modificato.

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

Rimuovi testo

È possibile rimuovere testo da una stringa usando il metodo String.Remove. Questo metodo rimuove un determinato numero di caratteri a partire da un indice specifico. Nell'esempio seguente viene illustrato come usare String.IndexOf seguito da Remove per rimuovere testo da una stringa:

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

Sostituire i criteri corrispondenti

È possibile usare le espressioni regolari per sostituire il testo corrispondente a determinati criteri con nuovo testo, che a sua volta può essere definito da un criterio. Nell'esempio seguente viene usata la classe System.Text.RegularExpressions.Regex per trovare un criterio in una stringa di origine e sostituirlo con la combinazione corretta di maiuscole e minuscole. Il metodo Regex.Replace(String, String, MatchEvaluator, RegexOptions) accetta una funzione che include tra i suoi argomenti la logica di sostituzione. In questo esempio la funzione (LocalReplaceMatchCase) è una funzione locale dichiarata all'interno del metodo di esempio. LocalReplaceMatchCase usa la classe System.Text.StringBuilder per compilare la stringa di sostituzione con la combinazione corretta di maiuscole e minuscole.

Le espressioni regolari sono utili soprattutto per la ricerca e sostituzione di testo corrispondente a un criterio, anziché di testo noto. Per altre informazioni, vedere Come cercare stringhe. Il criterio di ricerca "the\s" cerca la parola "the" seguita da uno spazio. Tale parte del criterio garantisce che nella stringa di origine non venga rilevata la corrispondenza con "there". Per altre informazioni sugli elementi del linguaggio delle espressioni regolari, vedere Linguaggio di espressioni regolari - Riferimento rapido.

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

Il metodo StringBuilder.ToString restituisce una stringa non modificabile con il contenuto dell'oggetto StringBuilder.

Modifica di caratteri singoli

È possibile produrre una matrice di caratteri da una stringa, modificare il contenuto della matrice e quindi creare una nuova stringa dal contenuto modificato della matrice.

Nell'esempio seguente viene illustrato come sostituire un gruppo di caratteri in una stringa. In primo luogo si usa il metodo String.ToCharArray() per creare una matrice di caratteri. Il metodo IndexOf viene usato per trovare l'indice iniziale della parola "fox". I tre caratteri successivi vengono sostituiti con una parola diversa. Infine viene creata una nuova stringa dalla matrice di caratteri aggiornata.

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

Creare contenuto stringa a livello di codice

Poiché le stringhe non sono modificabili, tutti gli esempi precedenti creano stringhe temporanee o matrici di caratteri. In scenari a prestazioni elevate, può essere consigliabile evitare queste allocazioni di heap. .NET Core fornisce un metodo String.Create che consente di compilare a livello di codice il contenuto di caratteri di una stringa tramite un callback evitando le allocazioni di stringhe temporanee intermedie.

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

È possibile modificare una stringa in un blocco fisso con codice non sicuro, ma è fortemente sconsigliato modificare il contenuto della stringa dopo la creazione di una stringa. In questo modo si romperanno le cose in modi imprevedibili. Ad esempio, se qualcuno inserisce una stringa con lo stesso contenuto della vostra, otterrà la vostra copia e non si aspetterà che stiate modificando la sua stringa.