Metodi delle stringhe in C#: Split, Replace, Contains, IndexOf, Trim, Join e altri

System.String ha decine di metodi. Questa pagina copre quelli che fanno la maggior parte del lavoro nel codice reale, con le opzioni e le trappole che contano. Una regola vale per tutti: le stringhe sono immutabili, quindi ogni metodo restituisce una nuova stringa (o un valore) e lascia l'originale invariato. s.Trim(); da solo su una riga non fa nulla; scrivi s = s.Trim();.

Split

Split spezza una stringa in uno string[] in corrispondenza di ogni separatore:

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

Output:

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

Nota " blue": Split taglia esattamente sul separatore e conserva gli spazi. Due opzioni gestiscono le pulizie più comuni:

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

Output:

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

RemoveEmptyEntries scarta le parti di lunghezza zero ma non quelle fatte solo di spazi (" " è sopravvissuto qui sopra). .NET 5 ha aggiunto StringSplitOptions.TrimEntries, e le due opzioni si possono combinare: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) dà il risultato pulito con una sola chiamata. Passare null come separatore divide su qualsiasi spazio bianco, ed è il modo abituale per dividere un testo in parole.

Dividere su un singolo char (Split(',')) non richiede un array. Gli overload che accettano un char più le opzioni, o una singola string, esistono da .NET Core 2.0 in poi; le forme con array usate sopra funzionano ovunque, anche su .NET Framework e Unity.

Replace

Replace sostituisce tutte le occorrenze di un carattere o di una sottostringa:

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

Output:

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

L'overload con un argomento StringComparison è disponibile su .NET Core 2.0 e successivi. Su .NET Framework la sostituzione senza distinzione tra maiuscole e minuscole si fa con Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Sostituire con "" è il modo per rimuovere caratteri, e concatenare diverse chiamate a Replace va benissimo per poche sostituzioni.

Contains, IndexOf, StartsWith ed EndsWith

Questi metodi cercano. Contains risponde sì o no; IndexOf e LastIndexOf restituiscono una posizione, oppure -1 quando non c'è corrispondenza; StartsWith ed EndsWith controllano le estremità.

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

Output:

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

Tutti distinguono maiuscole e minuscole per impostazione predefinita. Contains(string, StringComparison) esiste su .NET Core 2.1 e successivi; la forma IndexOf(...) >= 0 funziona in ogni versione, ed è per questo che la vedi nel codice più vecchio. IndexOfAny(new[] { ',', ';' }) trova il primo tra più caratteri.

Una nota sulla cultura: senza uno StringComparison, StartsWith, EndsWith, IndexOf(string) e CompareTo usano regole dipendenti dalla cultura, mentre Contains, Replace e IndexOf(char) confrontano in modo ordinale. Passare esplicitamente StringComparison.Ordinal o OrdinalIgnoreCase elimina l'ambiguità, ed è quello che raccomandano gli analizzatori di codice.

Trim, TrimStart e TrimEnd

Trim rimuove gli spazi bianchi (spazi, tabulazioni, a capo) da entrambe le estremità. TrimStart e TrimEnd rimuovono da una sola estremità. Se passi dei caratteri, rimuovono quelli:

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

Output:

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

Trim tocca solo le estremità; gli spazi all'interno della stringa restano. TrimStart('0') su "000" restituisce una stringa vuota, quindi analizza le stringhe numeriche con int.Parse invece di togliere gli zeri a mano.

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

Output:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper e ToLower seguono la cultura corrente, quindi in turco "i".ToUpper() è una İ maiuscola con il punto, non I. Per identificatori, chiavi e nomi di file usa ToUpperInvariant e ToLowerInvariant. Per confrontare, usa uno StringComparison invece di convertire le maiuscole (vedi stringhe). Per rendere maiuscola l'iniziale di ogni parola esiste CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), che però lascia stare le parole già tutte maiuscole.

PadLeft e PadRight

Il padding aggiunge caratteri finché la stringa non raggiunge una larghezza totale. È comodo per l'output a larghezza fissa e per aggiungere zeri iniziali ai codici:

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

Output:

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

L'allineamento nell'interpolazione ({name,-10}) fa lo stesso lavoro direttamente nella stringa.

Join e Concat

string.Join mette un separatore tra gli elementi di qualsiasi collezione. string.Concat unisce senza separatore:

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

Output:

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

Join è il modo giusto per costruire un elenco delimitato: non c'è un separatore finale da togliere, e costruisce il risultato in un solo passaggio. Chiama ToString() su ogni elemento, quindi funziona anche con numeri e oggetti.

Reverse, Insert e Remove

Non esiste un metodo string.Reverse che restituisca una stringa. I due approcci abituali:

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

Output:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

word.Reverse() da solo restituisce un IEnumerable<char>, non una stringa; stamparlo mostra il nome di un tipo. Entrambi i metodi invertono le unità di codice UTF-16, il che rompe i caratteri formati da due unità (la maggior parte delle emoji) e le lettere con accenti combinati.

Riferimento rapido