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

 

Suddivide una stringa in sottostringhe in base alle stringhe 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,
	StringSplitOptions options
)

Parametri

separator
Type: System.String[]

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

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
ArgumentException

options non è uno dei valori di StringSplitOptions.

Quando una stringa è delimitata da un set noto di stringhe, è possibile utilizzare la Split metodo per separarlo in sottostringhe.

Le stringhe di delimitazione non sono inclusi gli elementi della matrice restituita. Ad esempio, se la separator matrice include la stringa "-" e il valore dell'istanza della stringa corrente è "aa - bb-cc", il metodo restituisce una matrice che contiene tre elementi: "aa", "bb" e "cc".

Se questa istanza non contiene una delle stringhe in separator, la matrice restituita è costituito da un unico elemento che contiene questa istanza.

Se il options parametro RemoveEmptyEntries e la lunghezza di questa istanza è uguale a zero, il metodo restituisce una matrice vuota.

Ogni elemento di separator definisce un delimitatore separato costituito da uno o più caratteri. Se il options argomento 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 String.Empty. Ad esempio, se separator include due elementi, "-" e "_", il valore dell'istanza di stringa è "- _aa-_" e il valore della options argomento None, il metodo restituisce una matrice di stringa con i seguenti cinque elementi:

  1. String.Empty, che rappresenta una stringa vuota che precede il "-" sottostringa in corrispondenza dell'indice 0.

  2. String.Empty, che rappresenta la stringa vuota tra il "-" sottostringa in corrispondenza dell'indice 0 e la sottostringa "_" in corrispondenza dell'indice 1.

  3. "aa",

  4. String.Empty, che rappresenta la stringa vuota che segue la sottostringa "_" in corrispondenza dell'indice 4.

  5. String.Empty, che rappresenta la stringa vuota che segue il "-" sottostringa in corrispondenza dell'indice 5.

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 seguente: {"This", "is", "a", "string". }.

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.

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[]), StringSplitOptions.RemoveEmptyEntries);

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

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

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 il Split operazione procede dall'inizio alla fine del valore dell'istanza 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à una matrice di stringhe che contiene due elementi, "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à una matrice di stringhe che contiene due elementi, "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 una matrice di stringhe che contiene due elementi, "a" e "def".

Il Split 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.

Nell'esempio seguente viene illustrata la differenza matrici restituite chiamando una stringa String.Split(String[], StringSplitOptions) metodo con il relativo options uguale al parametro StringSplitOptions.None e StringSplitOptions.RemoveEmptyEntries.

using System;

class Example 
{
   public static void Main() 
   {
      string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
      string[] stringSeparators = new string[] {"[stop]"};
      string[] result;

      // Display the original string and delimiter string.
      Console.WriteLine("Splitting the string:\n   \"{0}\".", source);
      Console.WriteLine();
      Console.WriteLine("Using the delimiter string:\n   \"{0}\"", 
                        stringSeparators[0]);
      Console.WriteLine();                           

      // Split a string delimited by another string and return all elements.
      result = source.Split(stringSeparators, StringSplitOptions.None);
      Console.WriteLine("Result including all elements ({0} elements):", 
                        result.Length);
      Console.Write("   ");
      foreach (string s in result)
      {
         Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
      }
      Console.WriteLine();
      Console.WriteLine();

      // Split delimited by another string and return all non-empty elements.
      result = source.Split(stringSeparators, 
                            StringSplitOptions.RemoveEmptyEntries);
      Console.WriteLine("Result including non-empty elements ({0} elements):", 
                        result.Length);
      Console.Write("   ");
      foreach (string s in result)
      {
         Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Splitting the string:
//       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
//    
//    Using the delimiter string:
//       "[stop]"
//    
//    Result including all elements (9 elements):
//       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//    
//    Result including non-empty elements (3 elements):
//       'ONE' 'TWO' 'THREE'

L'esempio seguente definisce una matrice di separatori che includono la punteggiatura e caratteri di spazio vuoto. Il passaggio di questa matrice insieme a un valore di StringSplitOptions.RemoveEmptyEntries per il Split(String[], StringSplitOptions) metodo restituisce una matrice costituita da singole parole dalla stringa.

using System;

public class Example
{
   public static void Main()
   {
      string[] separators = {",", ".", "!", "?", ";", ":", " "};
      string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
      string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
      foreach (var word in words)
         Console.WriteLine(word);
   }
}
// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate

Note that the method is called with the options argument set to F:System.StringSplitOptions.RemoveEmptyEntries. This prevents the returned array from includingF:System.String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

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