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 (Char[], Int32, StringSplitOptions)

 

Suddivide una stringa in un numero massimo di sottostringhe in base ai caratteri in una matrice.

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

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

Parametri

separator
Type: System.Char[]

Matrice di caratteri 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 uno o più caratteri in separator. Per altre informazioni, vedere la sezione Osservazioni.

Exception Condition
ArgumentOutOfRangeException

count è negativo.

ArgumentException

options non è uno dei valori di StringSplitOptions.

Caratteri di delimitazione non sono inclusi gli elementi della matrice restituita.

Se questa istanza non contiene i caratteri 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(Char[]), 3, StringSplitOptions.RemoveEmptyEntries);

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

words = phrase.Split(null as char[], 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 carattere di delimitazione separato. 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.

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: