Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale
Questo argomento non è stato ancora valutato - Valuta questo argomento

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

Restituisce una matrice di stringhe contenente le sottostringhe di questa stringa delimitate dagli elementi di una matrice di caratteri Unicode specificata. Sono disponibili dei parametri per specificare il numero massimo di sottostringhe da restituire e se restituire elementi di matrice vuoti.

Spazio dei nomi:  System
Assembly:  mscorlib (in mscorlib.dll)
[ComVisibleAttribute(false)]
public string[] Split(
	char[] separator,
	int count,
	StringSplitOptions options
)

Parametri

separator
Tipo: System.Char[]
Matrice di caratteri Unicode che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.
count
Tipo: System.Int32
Numero massimo di sottostringhe da restituire.
options
Tipo: System.StringSplitOptions
StringSplitOptions.RemoveEmptyEntries per omettere gli elementi di matrice vuoti dalla matrice restituita; oppure StringSplitOptions.None per includere tali elementi.

Valore restituito

Tipo: System.String[]
Matrice i cui elementi contengono le sottostringhe in questa stringa delimitate da uno o più caratteri nel parametro separator. Per ulteriori informazioni, vedere la sezione "Note".
EccezioneCondizione
ArgumentOutOfRangeException

count è negativo.

ArgumentException

options non è uno dei valori di StringSplitOptions.

I caratteri di delimitazione non sono inclusi negli elementi della matrice restituita.

Se questa istanza non contiene alcun carattere fra quelli presenti nel parametro separator o il parametro count è 1, la matrice restituita è costituita da un unico elemento che contiene questa istanza. Se il parametro separator è null o non contiene alcun carattere, si utilizzano come delimitatori gli spazi vuoti. Gli spazi vuoti sono definiti da standard Unicode e restituiscono true se vengono passati al metodo Char.IsWhiteSpace. Tuttavia, se il parametro separator nella chiamata a questo overload del metodo è null, la risoluzione dell'overload del compilatore non riesce. Per identificare inequivocabilmente il metodo chiamato, il codice deve indicare il tipo null. Nell'esempio seguente vengono mostrati diversi modi per identificare inequivocabilmente 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 parametro count è zero o il parametro options è il campo RemoveEmptyEntries e la lunghezza di questa istanza è zero, viene restituita una matrice vuota.

Ogni elemento di separator definisce un carattere di delimitazione separato. Se il parametro options è il campo None e due limitatori sono adiacenti o un delimitatore si trova all'inizio o alla fine dell'istanza, l'elemento corrispondente della matrice contiene il campo Empty.

Se sono presenti più di count sottostringhe in questa istanza, vengono restituite le prime count -1 sottostringhe nei primi count -1 elementi del valore restituito, mentre i caratteri rimanenti di questa istanza vengono restituiti nell'ultimo elemento del valore restituito.

Se il parametro count è maggiore del numero delle sottostringhe, le sottostringhe disponibili verranno restituite e non sarà generata alcuna eccezione.

Considerazioni sulle prestazioni

I metodi Split allocano memoria per l'oggetto matrice restituito e un oggetto String per ogni elemento della matrice. Se le prestazioni dell'applicazione devono essere ottimali o se la gestione dell'allocazione di memoria riveste un'importanza fondamentale nell'applicazione, per individuare una sottostringa all'interno di una stringa è possibile utilizzare il metodo IndexOf o IndexOfAny ed eventualmente il metodo Compare.

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

In aggiunta, se per suddividere stringhe in più chiamate al metodo Split si utilizza lo stesso set di caratteri, prendere in considerazione di creare una sola matrice e farvi riferimento in ogni chiamata al metodo. In tal modo si ridurrà significativamente l'overhead aggiuntivo di ogni chiamata al metodo.

Note per i chiamanti

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

Nell'esempio riportato di seguito viene utilizzata l'enumerazione StringSplitOptions per includere o escludere le sottostringhe generate dal metodo Split.


// 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]>

*/


.NET Framework

Supportato in: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.
Il documento è risultato utile?
(1500 caratteri rimanenti)
Grazie per i commenti inviati.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft. Tutti i diritti riservati.