Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo String.Split (String[], Int32, StringSplitOptions)

 

Suddivide una stringa in un numero massimo di sottostringhe in base alle stringe in una matrice. È possibile specificare se le sottostringhe includono elementi della matrice vuota.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

[ComVisibleAttribute(false)]
public string[] Split(
	string[] separator,
	int count,
	StringSplitOptions options
)

Parametri

separator
Type: System.String[]

Matrice di stringhe che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.

count
Type: System.Int32

Numero massimo di sottostringhe da restituire.

options
Type: System.StringSplitOptions

StringSplitOptions.RemoveEmptyEntries per omettere gli elementi di matrice vuoti dalla matrice restituita; StringSplitOptions.None per includere tali elementi.

Valore restituito

Type: System.String[]

Matrice i cui elementi contengono le sottostringhe in questa stringa delimitate da una o più stringhe indicate in separator. Per altre informazioni, vedere la sezione Osservazioni.

Exception Condition
ArgumentOutOfRangeException

count è negativo.

ArgumentException

options non è uno dei valori di StringSplitOptions.

Le stringhe di delimitazione non sono inclusi gli elementi della matrice restituita.

Se questa istanza non contiene una delle stringhe in separator, o count parametro è 1, la matrice restituita è costituita da un unico elemento che contiene questa istanza. Se il separator parametro null o non contiene caratteri, spazi vuoti vengono considerati come delimitatori. Gli spazi vuoti sono definiti dallo standard Unicode e restituito true se vengono passati il Char.IsWhiteSpace metodo. Tuttavia, se il separator parametro nella chiamata a questo overload del metodo è null, la risoluzione dell'overload del compilatore non riesce. Per identificare in modo univoco il metodo chiamato, il codice deve indicare il tipo di null. Nell'esempio seguente mostra i diversi modi per identificare in modo univoco questo overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(string[]), 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((string[]) null, 3, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as string[], 3, StringSplitOptions.RemoveEmptyEntries);

Se il count parametro è uguale a zero, o options parametro RemoveEmptyEntries e la lunghezza di questa istanza è uguale a zero, viene restituita una matrice vuota.

Ogni elemento di separator definisce un delimitatore separato costituito da uno o più caratteri. Se il options parametro Nonee due i delimitatori sono adiacenti o un delimitatore si trova all'inizio o alla fine di questa istanza, l'elemento corrispondente della matrice contiene Empty.

Se sono presenti più di count sottostringhe di questa istanza, il primo count -1 sottostringhe vengono restituiti nel primo count vengono restituiti nell'ultimo elemento del valore restituito-1 elementi del valore restituito e i caratteri rimanenti in questa istanza.

Se count è maggiore del numero di sottostringhe, vengono restituite le sottostringhe disponibili e viene generata alcuna eccezione.

Se uno degli elementi in separator costituito da più caratteri, la sottostringa intera viene considerata un delimitatore. Ad esempio, se uno degli elementi in separator è "10", il tentativo di suddividere la stringa "This10is10a10string". Restituisce la matrice di quattro elementi: {"This", "is", "a", "string". }.

Il Split metodo estrae le sottostringhe di questa stringa delimitate da uno o più delle stringhe di separator parametro e restituisce le sottostringhe come elementi di una matrice.

Il Split metodo cerca i delimitatori eseguendo confronti utilizzando regole di ordinamento ordinali tra maiuscole e minuscole. Per ulteriori informazioni sulla parola, stringa e ordinale ordinamenti, vedere il System.Globalization.CompareOptions enumerazione.

Il Split metodo ignora qualsiasi elemento di separator il cui valore è null o una stringa vuota ("").

Per evitare risultati ambigui quando le stringhe nel separator hanno in comune, i caratteri di Split procede dall'inizio alla fine del valore dell'istanza del metodo e corrisponde al primo elemento separator che è uguale al delimitatore nell'istanza. L'ordine in cui le sottostringhe sono rilevate nell'istanza ha la precedenza sull'ordine degli elementi in separator.

Si consideri ad esempio un'istanza il cui valore è "abcdef". Se il primo elemento in separator è "ef" e il secondo elemento è stato "bcde", il risultato dell'operazione di divisione sarà "a" e "f". In questo modo la sottostringa nell'istanza, "bcde", viene rilevata e corrisponde a un elemento in separator prima che venga rilevata la sottostringa "f".

Tuttavia, se il primo elemento della separator è "bcd" e il secondo elemento è "bc", il risultato dell'operazione di divisione sarà "a" e "ef". Perché "bcd" è il primo delimitatore del separator che corrisponde a un delimitatore nell'istanza. Se il primo elemento è "bc" è stato annullato. l'ordine dei separatori e il secondo elemento è stato "bcd", il risultato sarebbe "a" e "def".

IlSplit metodi allocano memoria per l'oggetto matrice restituito e un String oggetto per ogni elemento della matrice. Se l'applicazione richiede di ottenere prestazioni ottimali, o se la gestione dell'allocazione di memoria critico dell'applicazione, è possibile utilizzare il IndexOf o IndexOfAny (metodo) e facoltativamente la Compare metodo, per individuare una sottostringa all'interno di una stringa.

Se si divide una stringa in un carattere separatore, utilizzare il IndexOf o IndexOfAny metodo per individuare un carattere di separazione della stringa. Se si divide una stringa in una stringa di separazione, utilizzare il IndexOf o IndexOfAny metodo per individuare il primo carattere della stringa di separazione. Utilizzare quindi la Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.

Inoltre, se lo stesso set di caratteri viene utilizzato per suddividere in più stringhe Split chiamate al metodo, prendere in considerazione la creazione di una matrice e farvi riferimento in ogni chiamata al metodo. Questo riduce notevolmente l'overhead aggiuntivo di ogni chiamata al metodo.

Note per i chiamanti:

Nel .NET Framework 3.5 e versioni precedenti, se il Split viene passato un separator ovvero null o non contiene caratteri, il metodo utilizza un set di caratteri leggermente diverso per suddividere la stringa che il Trim metodo consente di tagliare la stringa. Nel .NET Framework 4, entrambi i metodi utilizzano un set identico di caratteri spazi vuoti Unicode.

L'esempio seguente usa il StringSplitOptions enumerazione per includere o escludere le sottostringhe generate dal Split metodo.

// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
using System;

class Sample 
{
    public static void Main() 
    {
    string s1 = ",ONE,,TWO,,,THREE,,";
    string s2 = "[stop]" +
                "ONE[stop][stop]" +
                "TWO[stop][stop][stop]" +
                "THREE[stop][stop]";
    char[] charSeparators = new char[] {','};
    string[] stringSeparators = new string[] {"[stop]"};
    string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
    Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
    Console.WriteLine("1a )The original string is \"{0}\".", s1);
    Console.WriteLine("The delimiter character is '{0}'.\n", 
                       charSeparators[0]);

// Split a string delimited by characters and return all elements.
    Console.WriteLine("1b) Split a string delimited by characters and " +
                      "return all elements:");
    result = s1.Split(charSeparators, StringSplitOptions.None);
    Show(result);

// Split a string delimited by characters and return all non-empty elements.
    Console.WriteLine("1c) Split a string delimited by characters and " +
                      "return all non-empty elements:");
    result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
    Show(result);

// Split the original string into the string and empty string before the 
// delimiter and the remainder of the original string after the delimiter.
    Console.WriteLine("1d) Split a string delimited by characters and " +
                      "return 2 elements:");
    result = s1.Split(charSeparators, 2, StringSplitOptions.None);
    Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
    Console.WriteLine("1e) Split a string delimited by characters and " +
                      "return 2 non-empty elements:");
    result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
    Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
    Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
    Console.WriteLine("2a) The original string is \"{0}\".", s2);
    Console.WriteLine("The delimiter string is \"{0}\".\n", stringSeparators[0]);

// Split a string delimited by another string and return all elements.
    Console.WriteLine("2b) Split a string delimited by another string and " +
                      "return all elements:");
    result = s2.Split(stringSeparators, StringSplitOptions.None);
    Show(result);

// Split the original string at the delimiter and return all non-empty elements.
    Console.WriteLine("2c) Split a string delimited by another string and " +
                      "return all non-empty elements:");
    result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
    Show(result);

// Split the original string into the empty string before the 
// delimiter and the remainder of the original string after the delimiter.
    Console.WriteLine("2d) Split a string delimited by another string and " +
                      "return 2 elements:");
    result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
    Show(result);

// Split the original string into the string after the delimiter and the 
// remainder of the original string after the delimiter.
    Console.WriteLine("2e) Split a string delimited by another string and " + 
                      "return 2 non-empty elements:");
    result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
    Show(result);
    }

// Display the array of separated strings.
    public static void Show(string[] entries)
    {
    Console.WriteLine("The return value contains these {0} elements:", entries.Length);
    foreach (string entry in entries)
        {
        Console.Write("<{0}>", entry);
        }
    Console.Write("\n\n");
    }
}
/*
This example produces the following results:

1) Split a string delimited by characters:

1a )The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: