Rimuovere un carattere da una stringa in C#

Per rimuovere un carattere specifico da una stringa C#, chiama string.Replace() passando quel carattere e string.Empty. Per rimuovere più caratteri scelti, ripeti la sostituzione per ciascuno. Le stringhe sono immutabili, quindi ogni chiamata restituisce una nuova stringa; assegna il risultato se vuoi conservare la modifica. Scegli string.Split() insieme a string.Join() quando i caratteri sono delimitatori, Regex.Replace() per un pattern di caratteri oppure LINQ quando la regola specifica quali caratteri mantenere. Per rimuovere gli spazi bianchi, consulta come rimuovere gli spazi bianchi da una stringa in C#.

Rimuovere caratteri con string.Replace()

string.Replace() sostituisce ogni occorrenza del carattere o della sottostringa specificati. Sostituendo un carattere con string.Empty se ne rimuovono tutte le occorrenze. L’esempio seguente applica questa operazione a ciascun elemento di un insieme scelto; il valore restituito da ogni chiamata diventa l’input della successiva. Le stringhe di esempio e i relativi output sono in inglese.

Esegui questo esempio:

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

using System;

class Program
{
    static void Main()
    {
        string text = "Something @to ,Write.;';";
        char[] charactersToRemove = { '@', ',', '.', ';', '\'' };

        foreach (char character in charactersToRemove)
        {
            text = text.Replace(character.ToString(), string.Empty);
        }

        Console.WriteLine(text);
    }
}

Something to Write

Per un singolo carattere basta una chiamata, ad esempio text = text.Replace("@", string.Empty);. Il metodo rimuove tutte le corrispondenze, non soltanto la prima. Se l’insieme scelto è ampio, le chiamate ripetute eseguono più scansioni e creano stringhe intermedie; valuta un filtro di caratteri o un’espressione regolare quando la relativa regola è più chiara.

Rimuovere delimitatori con string.Split() e string.Join()

string.Split() tratta ogni carattere specificato come delimitatore e restituisce le sottostringhe comprese tra i delimitatori. string.Join() concatena queste parti usando il separatore fornito. Un separatore vuoto riunisce direttamente le parti rimanenti, rimuovendo così i delimitatori. È un altro modo per esprimere l’operazione, ma non è intrinsecamente migliore di string.Replace().

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

using System;

class Program
{
    static void Main()
    {
        string text = "Something @to ,Write.;';";
        char[] delimiters = { '@', ',', '.', ';', '\'' };
        string result = string.Join(string.Empty,
            text.Split(delimiters, StringSplitOptions.RemoveEmptyEntries));

        Console.WriteLine(result);
    }
}

Something to Write

StringSplitOptions.RemoveEmptyEntries scarta le parti vuote che possono comparire quando i delimitatori sono adiacenti oppure si trovano all’inizio o alla fine. Con l’input mostrato, riunire le parti ottenute con la divisione produce lo stesso testo visibile del ciclo di sostituzione. Usa questo approccio quando suddividere il testo in parti è utile di per sé; per eliminare semplicemente dei caratteri, string.Replace() è più diretto.

Rimuovere caratteri con Regex.Replace()

Regex.Replace() sostituisce ogni sottostringa che corrisponde a un pattern di espressione regolare. Una classe di caratteri come [@,.;'] corrisponde a uno qualsiasi dei caratteri elencati; sostituendo le corrispondenze con string.Empty si rimuove quindi l’insieme scelto. Caratteri come . hanno un significato speciale nelle espressioni regolari al di fuori di una classe di caratteri, ma in questo caso il punto è letterale.

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "Something @to ,Write.;';";
        string result = Regex.Replace(text, "[@,.;']", string.Empty);

        Console.WriteLine(result);
    }
}

Something to Write

Un’espressione regolare è utile quando la regola di rimozione descrive un pattern, per esempio un intervallo o una categoria di caratteri, anziché un breve elenco fisso. Se devono corrispondere letteralmente al di fuori di una classe di caratteri, esegui l’escape dei metacaratteri delle espressioni regolari. Per un elenco fisso, string.Replace() o string.Split() possono rendere più chiari i caratteri da rimuovere.

Filtrare i caratteri con LINQ

LINQ può creare una nuova stringa usando i caratteri che soddisfano una condizione. Questo esempio mantiene gli spazi bianchi, le lettere e le cifre, quindi rimuove la punteggiatura. È un filtro basato sulle proprietà dei caratteri, non la rimozione di un insieme arbitrario scelto dal chiamante: mantiene tutti i caratteri che soddisfano la regola, comprese le lettere e gli spazi.

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string text = "Something @to ,Write.;';";
        string result = new string(text
            .Where(character => char.IsWhiteSpace(character)
                || char.IsLetterOrDigit(character))
            .ToArray());

        Console.WriteLine(result);
    }
}

Something to Write

Usa LINQ quando la condizione per mantenere i caratteri è il modo più chiaro per esprimere il requisito. Se ti serve un insieme diverso, sostituisci char.IsWhiteSpace e char.IsLetterOrDigit con un predicato conforme alla tua regola. Per un elenco di caratteri esatti fornito dal chiamante, usa invece il ciclo di sostituzione o un test di appartenenza equivalente.