String.Split String.Split String.Split String.Split Method

Definizione

Restituisce una matrice di stringhe contenente le sottostringhe di questa istanza delimitate dagli elementi di una stringa o matrice di caratteri Unicode specificata.Returns a string array that contains the substrings in this instance that are delimited by elements of a specified string or Unicode character array.

Overload

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Suddivide una stringa in un numero massimo di sottostringhe in base ai caratteri in una matrice.Splits a string into a maximum number of substrings based on the characters in an array.

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

Suddivide una stringa in un numero massimo di sottostringhe in base alle stringe in una matrice.Splits a string into a maximum number of substrings based on the strings in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Suddivide una stringa in sottostringhe in base alle stringhe in una matrice.Splits a string into substrings based on the strings in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

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

Suddivide una stringa in sottostringhe in base ai caratteri in una matrice.Splits a string into substrings based on the characters in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Suddivide una stringa in un numero massimo di sottostringhe in base ai caratteri in una matrice.Splits a string into a maximum number of substrings based on the characters in an array. Numero massimo di sottostringhe da restituire.You also specify the maximum number of substrings to return.

Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Suddivide una stringa in sottostringhe basate sui caratteri in una matrice.Splits a string into substrings that are based on the characters in an array.

Commenti

Splitviene usato per suddividere una stringa delimitata in sottostringhe.Split is used to break a delimited string into substrings. È possibile usare una matrice di caratteri per specificare zero, uno o più caratteri di delimitazione (il Split(Char[]) metodo) oppure è possibile usare una matrice di caratteri per specificare zero, una o più stringhe di delimitazione.You can use either a character array to specify zero, one, or multiple delimiting characters (the Split(Char[]) method), or you can use a character array to specify zero, one, or multiple delimiting strings. Gli overload del Split metodo consentono di limitare il numero di sottostringhe restituite dal metodo Split(Char[], Int32) (metodo), per determinare se le stringhe vuote sono incluse nelle sottostringhe restituite, ovvero i Split(Char[], StringSplitOptions) metodi e Split(String[], StringSplitOptions) , oppure per eseguire entrambe le operazioni Split(Char[], Int32, StringSplitOptions) , Split(String[], Int32, StringSplitOptions) ovvero i metodi e.Overloads of the Split method allow you to limit the number of substrings returned by the method (the Split(Char[], Int32) method), to determine whether empty strings are included in the returned substrings (the Split(Char[], StringSplitOptions) and Split(String[], StringSplitOptions) methods, or to do both (the Split(Char[], Int32, StringSplitOptions) and Split(String[], Int32, StringSplitOptions) methods).

Nota

Gli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva.Select the Run button to run an example in an interactive window. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui.Once you execute the code, you can modify it and run the modified code by selecting Run again. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Alternative a String. SplitAlternatives to String.Split

Il Split metodo non è sempre il modo migliore per suddividere una stringa delimitata in sottostringhe.The Split method is not always the best way to break a delimited string into substrings. Se non si desidera estrarre tutte le sottostringhe di una stringa delimitata o se si desidera analizzare una stringa basata su un modello anziché su un set di caratteri delimitatori, considerare le alternative seguenti.If you don't want to extract all of the substrings of a delimited string, or if you want to parse a string based on a pattern instead of a set of delimiter characters, consider the following alternatives.

Espressioni regolariRegular expressions

Se le stringhe sono conformi a un modello fisso, è possibile usare un'espressione regolare per estrarre e gestire i relativi elementi.If your strings conform to a fixed pattern, you can use a regular expression to extract and handle their elements. Se, ad esempio, le stringhe hanno ilformato "numero operando ** numero", è possibile usare un' espressione regolare per estrarre e gestire gli elementi della stringa.For example, if strings take the form "number operand number" you can use a regular expression to extract and handle the string's elements. Di seguito è riportato un esempio:Here's an example:

   String[] expressions = { "16 + 21", "31 * 3", "28 / 3",
                            "42 - 18", "12 * 7",
                            "2, 4, 6, 8" };
   String pattern = @"(\d+)\s+([-+*/])\s+(\d+)";
   foreach (var expression in expressions)
      foreach (System.Text.RegularExpressions.Match m in 
      System.Text.RegularExpressions.Regex.Matches(expression, pattern)) {
         int value1 = Int32.Parse(m.Groups[1].Value);
         int value2 = Int32.Parse(m.Groups[3].Value);
         switch (m.Groups[2].Value)
         {
            case "+":
               Console.WriteLine("{0} = {1}", m.Value, value1 + value2);
               break;
            case "-":
               Console.WriteLine("{0} = {1}", m.Value, value1 - value2);
               break;
            case "*":
               Console.WriteLine("{0} = {1}", m.Value, value1 * value2);
               break;
            case "/":
               Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2);
               break;
         }
      }
// The example displays the following output:
//       16 + 21 = 37
//       31 * 3 = 93
//       28 / 3 = 9.33
//       42 - 18 = 24
//       12 * 7 = 84
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim expressions() As String = { "16 + 21", "31 * 3", "28 / 3",
                                      "42 - 18", "12 * 7",
                                      "2, 4, 6, 8" }

      Dim pattern As String = "(\d+)\s+([-+*/])\s+(\d+)"
      For Each expression In expressions
         For Each m As Match in Regex.Matches(expression, pattern)
            Dim value1 As Integer = Int32.Parse(m.Groups(1).Value)
            Dim value2 As Integer = Int32.Parse(m.Groups(3).Value)
            Select Case m.Groups(2).Value
               Case "+"
                  Console.WriteLine("{0} = {1}", m.Value, value1 + value2)
               Case "-"
                  Console.WriteLine("{0} = {1}", m.Value, value1 - value2)
               Case "*"
                  Console.WriteLine("{0} = {1}", m.Value, value1 * value2)
               Case "/"
                  Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2)
            End Select
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       16 + 21 = 37
'       31 * 3 = 93
'       28 / 3 = 9.33
'       42 - 18 = 24
'       12 * 7 = 84

Il criterio (\d+)\s+([-+*/])\s+(\d+) di ricerca di espressioni regolari è definito come segue:The regular expression pattern (\d+)\s+([-+*/])\s+(\d+) is defined like this:

ModelloPattern DescriptionDescription
(\d+) Trova la corrispondenza con una o più cifre decimali.Match one or more decimal digits. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\s+ Corrisponde a uno o più spazi vuoti.Match one or more white-space characters.
([-+*/]) Corrisponde a un segno di operatore aritmetico (+,-, * o/).Match an arithmetic operator sign (+, -, *, or /). Equivale al secondo gruppo di acquisizione.This is the second capturing group.
\s+ Corrisponde a uno o più spazi vuoti.Match one or more white-space characters.
(\d+) Trova la corrispondenza con una o più cifre decimali.Match one or more decimal digits. Equivale al terzo gruppo di acquisizione.This is the third capturing group.

È anche possibile usare un'espressione regolare per estrarre le sottostringhe da una stringa basata su un modello anziché su un set fisso di caratteri.You can also use a regular expression to extract substrings from a string based on a pattern rather than a fixed set of characters. Si tratta di uno scenario comune quando si verifica una delle condizioni seguenti:This is a common scenario when either of these conditions occurs:

  • Uno o più caratteri delimitatore non vengono sempre utilizzati come delimitatore nell' String istanza.One or more of the delimiter characters does not always serve as a delimiter in the String instance.

  • La sequenza e il numero di caratteri delimitatori sono variabili o sconosciute.The sequence and number of delimiter characters is variable or unknown.

Il Split metodo, ad esempio, non può essere usato per suddividere la stringa seguente, perché \n il numero C#di caratteri vbCrLf (in) o (in Visual Basic) è variabile e non sempre funge da delimitatori.For example, the Split method cannot be used to split the following string, because the number of \n (in C#) or vbCrLf (in Visual Basic) characters is variable, and they don't always serve as delimiters.

[This is captured\ntext.]\n\n[\n[This is more captured text.]\n]  
\n[Some more captured text:\n   Option1\n   Option2][Terse text.]  

Un'espressione regolare può suddividere facilmente la stringa, come illustrato nell'esempio seguente.A regular expression can split this string easily, as the following example shows.

String input = "[This is captured\ntext.]\n\n[\n" +
               "[This is more captured text.]\n]\n" +
               "[Some more captured text:\n   Option1" +
               "\n   Option2][Terse text.]";
String pattern = @"\[([^\[\]]+)\]";
int ctr = 0;
foreach (System.Text.RegularExpressions.Match m in 
   System.Text.RegularExpressions.Regex.Matches(input, pattern))
   Console.WriteLine("{0}: {1}", ++ctr, m.Groups[1].Value);
// The example displays the following output:
//       1: This is captured
//       text.
//       2: This is more captured text.
//       3: Some more captured text:
//          Option1
//          Option2
//       4: Terse text.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = String.Format("[This is captured{0}text.]" +
                                          "{0}{0}[{0}[This is more " +
                                          "captured text.]{0}{0}" +
                                          "[Some more captured text:" +
                                          "{0}   Option1" +
                                          "{0}   Option2][Terse text.]",
                                          vbCrLf)
      Dim pattern As String = "\[([^\[\]]+)\]"
      Dim ctr As Integer = 0
      For Each m As Match In Regex.Matches(input, pattern)
         ctr += 1
         Console.WriteLine("{0}: {1}", ctr, m.Groups(1).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       1: This is captured
'       text.
'       2: This is more captured text.
'       3: Some more captured text:
'          Option1
'          Option2
'       4: Terse text.

Il criterio \[([^\[\]]+)\] di ricerca di espressioni regolari è definito come segue:The regular expression pattern \[([^\[\]]+)\] is defined like this:

ModelloPattern DescriptionDescription
\[ Corrisponde a una parentesi di apertura.Match an opening bracket.
([^\[\]]+) Trovare la corrispondenza con qualsiasi carattere che non sia una parentesi di apertura o di chiusura una o più volte.Match any character that is not an opening or a closing bracket one or more times. Equivale al primo gruppo di acquisizione.This is the first capturing group.
\] Corrisponde a una parentesi di chiusura.Match a closing bracket.

Il Regex.Split metodo è quasi identico String.Splita, ad eccezione del fatto che suddivide una stringa in base a un modello di espressione regolare anziché a un set di caratteri fisso.The Regex.Split method is almost identical to String.Split, except that it splits a string based on a regular expression pattern instead of a fixed character set. Ad esempio, nell'esempio seguente viene usato Regex.Split il metodo per dividere una stringa che contiene sottostringhe delimitate da diverse combinazioni di trattini e altri caratteri.For example, the following example uses the Regex.Split method to split a string that contains substrings delimited by various combinations of hyphens and other characters.

String input = "abacus -- alabaster - * - atrium -+- " +
               "any -*- actual - + - armoire - - alarm";
String pattern = @"\s-\s?[+*]?\s?-\s";
String[] elements = System.Text.RegularExpressions.Regex.Split(input, pattern);
foreach (var element in elements)
   Console.WriteLine(element);

// The example displays the following output:
//       abacus
//       alabaster
//       atrium
//       any
//       actual
//       armoire
//       alarm
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "abacus -- alabaster - * - atrium -+- " +
                            "any -*- actual - + - armoir - - alarm"
      Dim pattern As String = "\s-\s?[+*]?\s?-\s"
      Dim elements() As String = Regex.Split(input, pattern)
      For Each element In elements
         Console.WriteLine(element)
      Next
   End Sub
End Module
' The example displays the following output:
'       abacus
'       alabaster
'       atrium
'       any
'       actual
'       armoir
'       alarm

Il criterio \s-\s?[+*]?\s?-\s di ricerca di espressioni regolari è definito come segue:The regular expression pattern \s-\s?[+*]?\s?-\s is defined like this:

ModelloPattern DescriptionDescription
\s- Corrisponde a uno spazio vuoto seguito da un trattino.Match a white-space character followed by a hyphen.
\s? Trova la corrispondenza di uno o nessuno spazio vuoto.Match zero or one white-space character.
[+*]? Trovare la corrispondenza con zero o una occorrenza del carattere + o *.Match zero or one occurrence of either the + or * character.
\s? Trova la corrispondenza di uno o nessuno spazio vuoto.Match zero or one white-space character.
-\s Corrisponde a un trattino seguito da uno spazio vuoto.Match a hyphen followed by a white-space character.

Metodi di ricerca e metodo substringSearch methods and the Substring method

Se non si è interessati a tutte le sottostringhe di una stringa, è preferibile usare uno dei metodi di confronto tra stringhe che restituisce l'indice in corrispondenza del quale inizia la corrispondenza.If you aren't interested in all of the substrings in a string, you might prefer to work with one of the string comparison methods that returns the index at which the match begins. È quindi possibile chiamare il Substring metodo per estrarre la sottostringa desiderata.You can then call the Substring method to extract the substring that you want. I metodi di confronto tra stringhe includono:The string comparison methods include:

  • IndexOf, che restituisce l'indice in base zero della prima occorrenza di un carattere o di una stringa in un'istanza di stringa.IndexOf, which returns the zero-based index of the first occurrence of a character or string in a string instance.

  • IndexOfAny, che restituisce l'indice in base zero nell'istanza di stringa corrente della prima occorrenza di qualsiasi carattere in una matrice di caratteri.IndexOfAny, which returns the zero-based index in the current string instance of the first occurrence of any character in a character array.

  • LastIndexOf, che restituisce l'indice in base zero dell'ultima occorrenza di un carattere o di una stringa in un'istanza di stringa.LastIndexOf, which returns the zero-based index of the last occurrence of a character or string in a string instance.

  • LastIndexOfAny, che restituisce un indice in base zero nell'istanza di stringa corrente dell'ultima occorrenza di qualsiasi carattere in una matrice di caratteri.LastIndexOfAny, which returns a zero-based index in the current string instance of the last occurrence of any character in a character array.

Nell'esempio seguente viene usato IndexOf il metodo per individuare i punti in una stringa.The following example uses the IndexOf method to find the periods in a string. USA quindi il Substring metodo per restituire frasi complete.It then uses the Substring method to return full sentences.

String value = "This is the first sentence in a string. " +
               "More sentences will follow. For example, " +
               "this is the third sentence. This is the " +
               "fourth. And this is the fifth and final " +
               "sentence.";
var sentences = new List<String>();
int position = 0;
int start = 0;
// Extract sentences from the string.
do 
{
   position = value.IndexOf('.', start);
   if (position >= 0) 
   {
      sentences.Add(value.Substring(start, position - start + 1).Trim());
      start = position + 1;
   }
} while (position > 0);

// Display the sentences.
foreach (var sentence in sentences)
   Console.WriteLine(sentence);

// The example displays the following output:
//       This is the first sentence in a string.
//       More sentences will follow.
//       For example, this is the third sentence.
//       This is the fourth.
//       And this is the fifth and final sentence.
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim value As String = "This is the first sentence in a string. " +
                            "More sentences will follow. For example, " +
                            "this is the third sentence. This is the " +
                            "fourth. And this is the fifth and final " +
                            "sentence."
      Dim sentences As New List(Of String)
      Dim position As Integer = 0
      Dim start As Integer = 0
      ' Extract sentences from the string.
      Do
         position = value.IndexOf("."c, start)
         If position >= 0 Then
            sentences.Add(value.Substring(start, position - start + 1).Trim())
            start = position + 1
         End If
      Loop While position > 0
      
      ' Display the sentences.
      For Each sentence In sentences
         Console.WriteLine(sentence)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence in a string.
'       More sentences will follow.
'       For example, this is the third sentence.
'       This is the fourth.
'       And this is the fifth and final sentence.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Suddivide una stringa in un numero massimo di sottostringhe in base ai caratteri in una matrice.Splits a string into a maximum number of substrings based on the characters in an array.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, int count, StringSplitOptions options);
member this.Split : char[] * int * StringSplitOptions -> string[]
Public Function Split (separator As Char(), count As Integer, options As StringSplitOptions) As String()

Parametri

separator
Char[]

Matrice di caratteri che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

Numero massimo di sottostringhe da restituire.The maximum number of substrings to return.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries per omettere gli elementi di matrice vuoti dalla matrice restituita; None per includere tali elementi.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Restituisce

String[]

Matrice i cui elementi contengono le sottostringhe in questa stringa delimitate da uno o più caratteri in separator.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

Eccezioni

options non è uno dei valori di StringSplitOptions.options is not one of the StringSplitOptions values.

Esempi

Nell'esempio seguente viene usata StringSplitOptions l'enumerazione per includere o escludere sottostringhe generate Split dal metodo.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
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 using a local function
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]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, 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:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, 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)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'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]>
'

Commenti

I caratteri delimitatori non sono inclusi negli elementi della matrice restituita.Delimiter characters are not included in the elements of the returned array.

Se questa istanza non contiene caratteri in separatoro se il count parametro è 1, la matrice restituita è costituita da un singolo elemento che contiene questa istanza.If this instance does not contain any of the characters in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. Se il separator parametro è null o non contiene caratteri, si presuppone che gli spazi vuoti siano i delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti vengono definiti dallo standard Unicode e restituiscono true se vengono passati Char.IsWhiteSpace al metodo.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Tuttavia, se il separator parametro nella chiamata a questo overload del metodo è null, la risoluzione dell'overload del compilatore ha esito negativo.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Per identificare in modo univoco il metodo chiamato, il codice deve indicare il tipo del valore null.To unambiguously identify the called method, your code must indicate the type of the null. Nell'esempio seguente vengono illustrati diversi modi per identificare in modo univoco questo overload.The following example shows several ways to unambiguously identify this 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);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, Char()), 3, 
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New Char() {}, 3,
                     StringSplitOptions.RemoveEmptyEntries)

Se il count parametro è zero o il options parametro è RemoveEmptyEntries e la lunghezza di questa istanza è zero, viene restituita una matrice vuota.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Ogni elemento di separator definisce un carattere delimitatore separato.Each element of separator defines a separate delimiter character. Se il options parametro è Nonee due delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente Emptycontiene.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Se sono presenti più di count sottostringhe in questa istanza, le prime count sottostringhe meno 1 vengono restituite nei primi count meno 1 elementi del valore restituito e i caratteri rimanenti in questa istanza vengono restituiti negli ultimi elemento del valore restituito.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Se count è maggiore del numero di sottostringhe, vengono restituite le sottostringhe disponibili e non viene generata alcuna eccezione.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Considerazioni sulle prestazioniPerformance Considerations

I Split metodi allocano memoria per l'oggetto matrice restituito e String un oggetto per ogni elemento della matrice.The Split methods allocate memory for the returned array object and a String object for each array element. Se l'applicazione richiede prestazioni ottimali o se la gestione dell'allocazione di memoria è fondamentale nell'applicazione IndexOf , IndexOfAny è consigliabile usare il metodo o Compare e, facoltativamente, il metodo, per individuare una sottostringa all'interno di una stringa.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Se si divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Inoltre, se si usa lo stesso set di caratteri per suddividere le stringhe in Split più chiamate al metodo, è consigliabile creare una singola matrice e farvi riferimento in ogni chiamata al metodo.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Questo riduce significativamente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Trim(Char[]) null separator Split(Char[]) In e versioni precedenti, se al metodo viene passato un oggetto che è o non contiene caratteri, il metodo usa un set di caratteri leggermente diverso per suddividere la stringa rispetto al metodo .NET Framework 3.5.NET Framework 3.5 tagliare la stringa.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)

public string[] Split (char separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * int * StringSplitOptions -> string[]
Public Function Split (separator As Char, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parametri

separator
Char Char Char Char

Restituisce

String[]

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

Suddivide una stringa in un numero massimo di sottostringhe in base alle stringe in una matrice.Splits a string into a maximum number of substrings based on the strings in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, int count, StringSplitOptions options);
member this.Split : string[] * int * StringSplitOptions -> string[]
Public Function Split (separator As String(), count As Integer, options As StringSplitOptions) As String()

Parametri

separator
String[]

Matrice di stringhe che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

Numero massimo di sottostringhe da restituire.The maximum number of substrings to return.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries per omettere gli elementi di matrice vuoti dalla matrice restituita; None per includere tali elementi.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Restituisce

String[]

Matrice i cui elementi contengono le sottostringhe in questa stringa delimitate da una o più stringhe indicate in separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

Eccezioni

options non è uno dei valori di StringSplitOptions.options is not one of the StringSplitOptions values.

Esempi

Nell'esempio seguente viene usata StringSplitOptions l'enumerazione per includere o escludere sottostringhe generate Split dal metodo.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
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 using a local function
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]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, 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:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, 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)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'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]>
'

Commenti

Dettagli valore restituitoReturn value details

Le stringhe delimitatore non sono incluse negli elementi della matrice restituita.Delimiter strings are not included in the elements of the returned array.

Se questa istanza non contiene stringhe in separatoro il count parametro è 1, la matrice restituita è costituita da un singolo elemento che contiene questa istanza.If this instance does not contain any of the strings in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. Se il separator parametro è null o non contiene caratteri, si presuppone che gli spazi vuoti siano i delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti vengono definiti dallo standard Unicode e restituiscono true se vengono passati Char.IsWhiteSpace al metodo.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Tuttavia, se il separator parametro nella chiamata a questo overload del metodo è null, la risoluzione dell'overload del compilatore ha esito negativo.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Per identificare in modo univoco il metodo chiamato, il codice deve indicare il tipo di null.To unambiguously identify the called method, your code must indicate the type of the null. Nell'esempio seguente vengono illustrati diversi modi per identificare in modo univoco questo overload.The following example shows several ways to unambiguously identify this 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);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, String()), 3, 
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New String() {}, 3,
                     StringSplitOptions.RemoveEmptyEntries)

Se il count parametro è zero o il options parametro è RemoveEmptyEntries e la lunghezza di questa istanza è zero, viene restituita una matrice vuota.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Ogni elemento di separator definisce un delimitatore separato costituito da uno o più caratteri.Each element of separator defines a separate delimiter that consists of one or more characters. Se il options parametro è Nonee due delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente Emptycontiene.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Se sono presenti più di count sottostringhe in questa istanza, le prime count sottostringhe meno 1 vengono restituite nei primi count meno 1 elementi del valore restituito e i caratteri rimanenti in questa istanza vengono restituiti negli ultimi elemento del valore restituito.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Se count è maggiore del numero di sottostringhe, vengono restituite le sottostringhe disponibili e non viene generata alcuna eccezione.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Matrice di separatoreThe separator array

Se uno degli elementi in separator è costituito da più caratteri, l'intera sottostringa viene considerata un delimitatore.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Ad esempio, se uno degli elementi in separator è "10", il tentativo di dividere la stringa "This10is10a10string".For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." Restituisce la matrice a quattro elementi: {"This", "is", "a", "String".returns this four-element array: { "This", "is", "a", "string." }.}.

Dettagli confrontoComparison details

Il Split metodo estrae le sottostringhe di questa stringa delimitate da una o più stringhe separator nel parametro e restituisce tali sottostringhe come elementi di una matrice.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Il Split metodo cerca i delimitatori eseguendo confronti usando le regole di ordinamento ordinali con distinzione tra maiuscole e minuscole.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per ulteriori informazioni sugli ordinamenti di Word, stringa e ordinali, System.Globalization.CompareOptions vedere l'enumerazione.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Il Split metodo ignora qualsiasi elemento di separator il cui valore è null o la stringa vuota ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Per evitare risultati ambigui quando le separator stringhe in contengono caratteri in comune Split , il metodo procede dall'inizio alla fine del valore dell'istanza e trova la corrispondenza con il primo elemento in separator che è uguale a un delimitatore nel istanza.To avoid ambiguous results when strings in separator have characters in common, the Split method proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. L'ordine in cui le sottostringhe vengono rilevate nell'istanza ha la precedenza sull'ordine degli separatorelementi in.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Si consideri, ad esempio, un'istanza il cui valore è "abcdef".For example, consider an instance whose value is "abcdef". Se il primo elemento in separator è "EF" e il secondo elemento è "bcde", il risultato dell'operazione Split sarà "a" e "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be "a" and "f". Ciò è dovuto al fatto che la sottostringa nell'istanza di, "bcde", viene rilevata e corrisponde a un elemento in separator prima che venga rilevata la sottostringa "f".This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Tuttavia, se il primo elemento di separator era "BCD" e il secondo elemento era "BC", il risultato dell'operazione Split sarebbe "a" e "EF".However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be "a" and "ef". Questo perché "BCD" è il primo delimitatore in separator che corrisponde a un delimitatore nell'istanza.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Se l'ordine dei separatori è stato invertito in modo che il primo elemento fosse "BC" e il secondo elemento fosse "BCD", il risultato sarà "a" e "def".If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be "a" and "def".

Considerazioni sulle prestazioniPerformance considerations

I Split metodi allocano memoria per l'oggetto matrice restituito e String un oggetto per ogni elemento della matrice.The Split methods allocate memory for the returned array object and a String object for each array element. Se l'applicazione richiede prestazioni ottimali o se la gestione dell'allocazione di memoria è fondamentale nell'applicazione IndexOf , IndexOfAny è consigliabile usare il metodo o Compare e, facoltativamente, il metodo, per individuare una sottostringa all'interno di una stringa.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Se si divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Inoltre, se si usa lo stesso set di caratteri per suddividere le stringhe in Split più chiamate al metodo, è consigliabile creare una singola matrice e farvi riferimento in ogni chiamata al metodo.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Questo riduce significativamente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Trim(Char[]) null separator Split(Char[]) In e versioni precedenti, se al metodo viene passato un oggetto che è o non contiene caratteri, il metodo usa un set di caratteri leggermente diverso per suddividere la stringa rispetto al metodo .NET Framework 3.5.NET Framework 3.5 tagliare la stringa.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Suddivide una stringa in sottostringhe in base alle stringhe in una matrice.Splits a string into substrings based on the strings in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, StringSplitOptions options);
member this.Split : string[] * StringSplitOptions -> string[]
Public Function Split (separator As String(), options As StringSplitOptions) As String()

Parametri

separator
String[]

Matrice di stringhe che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries per omettere gli elementi di matrice vuoti dalla matrice restituita; None per includere tali elementi.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Restituisce

String[]

Matrice i cui elementi contengono le sottostringhe in questa stringa delimitate da una o più stringhe indicate in separator.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

Eccezioni

options non è uno dei valori di StringSplitOptions.options is not one of the StringSplitOptions values.

Esempi

Nell'esempio seguente viene illustrata la differenza nelle matrici restituite chiamando String.Split(String[], StringSplitOptions) il metodo di una stringa con il relativo options parametro uguale StringSplitOptions.None a StringSplitOptions.RemoveEmptyEntriese.The following example illustrates the difference in the arrays returned by calling a string's String.Split(String[], StringSplitOptions) method with its options parameter equal to StringSplitOptions.None and StringSplitOptions.RemoveEmptyEntries.

   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'
Module Example
   Public Sub Main()
      Dim source As String = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
      Dim stringSeparators() As String = {"[stop]"}
      Dim result() As String
      
      ' Display the original string and delimiter string.
      Console.WriteLine("Splitting the string:{0}   '{1}'.", vbCrLf, source)
      Console.WriteLine()
      Console.WriteLine("Using the delimiter string:{0}   '{1}'.", _
                        vbCrLf, 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("   ")
      For Each s As String In result
         Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))                   
      Next
      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("   ")
      For Each s As String In result
         Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))                   
      Next
      Console.WriteLine()
   End Sub
End Module
' 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'

Nell'esempio seguente viene definita una matrice di separatori che includono segni di punteggiatura e spazi vuoti.The following example defines an array of separators that include punctuation and white-space characters. Il passaggio di questa matrice insieme a un StringSplitOptions.RemoveEmptyEntries valore di Split(String[], StringSplitOptions) al metodo restituisce una matrice costituita dalle singole parole della stringa.Passing this array along with a value of StringSplitOptions.RemoveEmptyEntries to the Split(String[], StringSplitOptions) method returns an array that consists of the individual words from the string.

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
Module Example
   Public Sub Main()
      Dim separators() As String = {",", ".", "!", "?", ";", ":", " "}
      Dim value As String = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
      Dim words() As String = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
      For Each word In words
         Console.WriteLine(word)
      Next   
   End Sub
End Module
' The example displays the following output:
'       The
'       handsome
'       energetic
'       young
'       dog
'       was
'       playing
'       with
'       his
'       smaller
'       more
'       lethargic
'       litter
'       mate

Si noti che il metodo viene chiamato con options l'argomento impostato StringSplitOptions.RemoveEmptyEntriessu.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. In questo modo si impedisce che la String.Empty matrice restituita includa valori che rappresentano corrispondenze di sottostringhe vuote tra i segni di punteggiatura e gli spazi vuoti.This prevents the returned array from including String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Commenti

Quando una stringa è delimitata da un set di stringhe noto, è possibile usare il Split metodo per separarlo in sottostringhe.When a string is delimited by a known set of strings, you can use the Split method to separate it into substrings.

Dettagli valore restituitoReturn value details

Le stringhe delimitatore non sono incluse negli elementi della matrice restituita.Delimiter strings are not included in the elements of the returned array. Se, ad esempio, separator la matrice include la stringa "--" e il valore dell'istanza di stringa corrente è "AA--BB-CC", il metodo restituisce una matrice che contiene tre elementi: "AA", "BB" e "CC".For example, if the separator array includes the string "--" and the value of the current string instance is "aa--bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Se questa istanza non contiene stringhe in separator, la matrice restituita è costituita da un singolo elemento che contiene questa istanza.If this instance does not contain any of the strings in separator, the returned array consists of a single element that contains this instance.

Se il options parametro è RemoveEmptyEntries e la lunghezza di questa istanza è zero, il metodo restituisce una matrice vuota.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Ogni elemento di separator definisce un delimitatore separato costituito da uno o più caratteri.Each element of separator defines a separate delimiter that consists of one or more characters. Se l' options argomento è Nonee due delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente String.Emptycontiene.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. separator Se, ad esempio, sono inclusi due elementi, "-"_e "", il valore dell'istanza di stringa è_"-_AA options -" e il valore dell'argomento è None, il metodo restituisce una matrice Sting con i cinque elementi seguenti:For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a sting array with the following five elements:

  1. String.Empty, che rappresenta la stringa vuota che precede la sottostringa "-" in corrispondenza dell'indice 0.String.Empty, which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty, che rappresenta la stringa vuota tra la sottostringa "-" in corrispondenza dell'indice 0 e la sottostringa "" in corrispondenza dell'indice 1.String.Empty, which represents the empty string between the "-" substring at index 0 and the "" substring at index 1.

  3. "AA","aa",

  4. String.Empty, che rappresenta la stringa vuota che segue la sottostringa "" in corrispondenza dell'indice 4.String.Empty, which represents the empty string that follows the "" substring at index 4.

  5. String.Empty, che rappresenta la stringa vuota che segue la sottostringa "-" in corrispondenza dell'indice 5.String.Empty, which represents the empty string that follows the "-" substring at index 5.

Matrice di separatoreThe separator array

Se uno degli elementi in separator è costituito da più caratteri, l'intera sottostringa viene considerata un delimitatore.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Ad esempio, se uno degli elementi in separator è "10", il tentativo di dividere la stringa "This10is10a10string".For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." Restituisce la matrice di quattro elementi seguente: {"This", "is", "a", "String".returns the following four-element array: { "This", "is", "a", "string." }.}.

Se il separator parametro è null o non contiene caratteri, si presuppone che gli spazi vuoti siano i delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti vengono definiti dallo standard Unicode e restituiscono true se vengono passati Char.IsWhiteSpace al metodo.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Se il separator parametro nella chiamata a questo overload del metodo è null, la risoluzione dell'overload del compilatore ha esito negativo.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Per identificare in modo univoco il metodo chiamato, il codice deve indicare il tipo di null.To unambiguously identify the called method, your code must indicate the type of the null. Nell'esempio seguente vengono illustrati diversi modi per identificare in modo univoco questo overload.The following example shows several ways to unambiguously identify this 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);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, String()),  
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New String() {},
                     StringSplitOptions.RemoveEmptyEntries)

Dettagli confrontoComparison details

Il Split metodo estrae le sottostringhe di questa stringa delimitate da una o più stringhe separator nel parametro e restituisce tali sottostringhe come elementi di una matrice.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Il Split metodo cerca i delimitatori eseguendo confronti usando le regole di ordinamento ordinali con distinzione tra maiuscole e minuscole.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per ulteriori informazioni sugli ordinamenti di Word, stringa e ordinali, System.Globalization.CompareOptions vedere l'enumerazione.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Il Split metodo ignora qualsiasi elemento di separator il cui valore è null o la stringa vuota ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Per evitare risultati ambigui quando le separator stringhe in contengono caratteri in comune Split , l'operazione procede dall'inizio alla fine del valore dell'istanza e corrisponde al primo elemento in separator che è uguale a un delimitatore nel istanza.To avoid ambiguous results when strings in separator have characters in common, the Split operation proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. L'ordine in cui le sottostringhe vengono rilevate nell'istanza ha la precedenza sull'ordine degli separatorelementi in.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Si consideri, ad esempio, un'istanza il cui valore è "abcdef".For example, consider an instance whose value is "abcdef". Se il primo elemento in separator è "EF" e il secondo elemento è "bcde", il risultato dell'operazione Split sarà una matrice di stringhe che contiene due elementi, "a" e "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be a string array that contains two elements, "a" and "f". Ciò è dovuto al fatto che la sottostringa nell'istanza di, "bcde", viene rilevata e corrisponde a un elemento in separator prima che venga rilevata la sottostringa "f".This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Tuttavia, se il primo elemento di separator era "BCD" e il secondo elemento era "BC", il risultato dell'operazione Split sarebbe una matrice di stringhe che contiene due elementi, "a" e "EF".However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be a string array that contains two elements, "a" and "ef". Questo perché "BCD" è il primo delimitatore in separator che corrisponde a un delimitatore nell'istanza.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Se l'ordine dei separatori è stato invertito in modo che il primo elemento fosse "BC" e il secondo elemento fosse "BCD", il risultato sarà una matrice di stringhe che contiene due elementi, "a" e "def".If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be a string array that contains two elements, "a" and "def".

Considerazioni sulle prestazioniPerformance considerations

I Split metodi allocano memoria per l'oggetto matrice restituito e String un oggetto per ogni elemento della matrice.The Split methods allocate memory for the returned array object and a String object for each array element. Se l'applicazione richiede prestazioni ottimali o se la gestione dell'allocazione di memoria è fondamentale nell'applicazione IndexOf , IndexOfAny è consigliabile usare il metodo o Compare e, facoltativamente, il metodo, per individuare una sottostringa all'interno di una stringa.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Se si divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Inoltre, se si usa lo stesso set di caratteri per suddividere le stringhe in Split più chiamate al metodo, è consigliabile creare una singola matrice e farvi riferimento in ogni chiamata al metodo.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Questo riduce significativamente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Trim(Char[]) null separator Split(Char[]) In e versioni precedenti, se al metodo viene passato un oggetto che è o non contiene caratteri, il metodo usa un set di caratteri leggermente diverso per suddividere la stringa rispetto al metodo .NET Framework 3.5.NET Framework 3.5 tagliare la stringa.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)

public string[] Split (string separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * int * StringSplitOptions -> string[]
Public Function Split (separator As String, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parametri

Restituisce

String[]

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

Suddivide una stringa in sottostringhe in base ai caratteri in una matrice.Splits a string into substrings based on the characters in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, StringSplitOptions options);
member this.Split : char[] * StringSplitOptions -> string[]
Public Function Split (separator As Char(), options As StringSplitOptions) As String()

Parametri

separator
Char[]

Matrice di caratteri che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions StringSplitOptions StringSplitOptions StringSplitOptions

RemoveEmptyEntries per omettere gli elementi di matrice vuoti dalla matrice restituita; None per includere tali elementi.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

Restituisce

String[]

Matrice i cui elementi contengono le sottostringhe in questa stringa delimitate da uno o più caratteri in separator.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

Eccezioni

options non è uno dei valori di StringSplitOptions.options is not one of the StringSplitOptions values.

Esempi

Nell'esempio seguente viene usata StringSplitOptions l'enumerazione per includere o escludere sottostringhe generate Split dal metodo.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String() methods that use
// the StringSplitOptions enumeration.
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 using a local function
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]>

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, 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:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, 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)
    
    End Sub
    
    
    ' Display the array of separated strings.
    Public Shared Sub Show(ByVal entries() As String) 
        Console.WriteLine("The return value contains these {0} elements:", entries.Length)
        Dim entry As String
        For Each entry In  entries
            Console.Write("<{0}>", entry)
        Next entry
        Console.Write(vbCrLf & vbCrLf)
    
    End Sub
End Class
'
'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]>
'

Commenti

Dettagli valore restituitoReturn value details

I caratteri delimitatori (i caratteri nella separator matrice) non sono inclusi negli elementi della matrice restituita.Delimiter characters (the characters in the separator array) are not included in the elements of the returned array. Se, ad esempio, separator la matrice include il carattere "-" e il valore dell'istanza di stringa corrente è "AA-BB-CC", il metodo restituisce una matrice che contiene tre elementi: "AA", "BB" e "CC".For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Se questa istanza non contiene alcun carattere in separator, la matrice restituita è costituita da un singolo elemento che contiene questa istanza.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Se il options parametro è RemoveEmptyEntries e la lunghezza di questa istanza è zero, il metodo restituisce una matrice vuota.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Ogni elemento di separator definisce un delimitatore separato costituito da un singolo carattere.Each element of separator defines a separate delimiter that consists of a single character. Se l' options argomento è Nonee due delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente String.Emptycontiene.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. separator Se, ad esempio, sono inclusi due elementi, "-"_e "", il valore dell'istanza di stringa è_"-_AA options -" e il valore dell'argomento è None, il metodo restituisce una matrice di stringhe con i cinque elementi seguenti:For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a string array with the following five elements:

  1. String.Empty, che rappresenta la stringa vuota che precede il carattere "-" in corrispondenza dell'indice 0.String.Empty, which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty, che rappresenta la stringa vuota tra il carattere "-" in corrispondenza dell'indice 0 e il carattere "" in corrispondenza dell'indice 1.String.Empty, which represents the empty string between the "-" character at index 0 and the "" character at index 1.

  3. "AA","aa",

  4. String.Empty, che rappresenta la stringa vuota che segue il carattere "" in corrispondenza dell'indice 4.String.Empty, which represents the empty string that follows the "" character at index 4.

  5. String.Empty, che rappresenta la stringa vuota che segue il carattere "-" in corrispondenza dell'indice 5.String.Empty, which represents the empty string that follows the "-" character at index 5.

Matrice di separatoreThe separator array

Se il separator parametro è null o non contiene caratteri, si presuppone che gli spazi vuoti siano i delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti vengono definiti dallo standard Unicode e restituiscono true se vengono passati Char.IsWhiteSpace al metodo.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Se il separator parametro nella chiamata a questo overload del metodo è null, la risoluzione dell'overload del compilatore ha esito negativo.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Per identificare in modo univoco il metodo chiamato, il codice deve indicare il tipo di null.To unambiguously identify the called method, your code must indicate the type of the null. Nell'esempio seguente vengono illustrati diversi modi per identificare in modo univoco questo overload.The following example shows several ways to unambiguously identify this overload.

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

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

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

words = phrase.Split(null as char[], StringSplitOptions.RemoveEmptyEntries);
Dim phrase As String = "The quick brown fox"
Dim words() As String

words = phrase.Split(TryCast(Nothing, Char()),  
                       StringSplitOptions.RemoveEmptyEntries)

words = phrase.Split(New Char() {}, 
                     StringSplitOptions.RemoveEmptyEntries)

Dettagli confrontoComparison details

Il Split metodo estrae le sottostringhe di questa stringa delimitate da uno o più caratteri separator nel parametro e restituisce tali sottostringhe come elementi di una matrice.The Split method extracts the substrings in this string that are delimited by one or more of the characters in the separator parameter, and returns those substrings as elements of an array.

Il Split metodo cerca i delimitatori eseguendo confronti usando le regole di ordinamento ordinali con distinzione tra maiuscole e minuscole.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per ulteriori informazioni sugli ordinamenti di Word, stringa e ordinali, System.Globalization.CompareOptions vedere l'enumerazione.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considerazioni sulle prestazioniPerformance Considerations

I Split metodi allocano memoria per l'oggetto matrice restituito e String un oggetto per ogni elemento della matrice.The Split methods allocate memory for the returned array object and a String object for each array element. Se l'applicazione richiede prestazioni ottimali o se la gestione dell'allocazione di memoria è fondamentale nell'applicazione IndexOf , IndexOfAny è consigliabile usare il metodo o Compare e, facoltativamente, il metodo, per individuare una sottostringa all'interno di una stringa.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Se si divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Inoltre, se si usa lo stesso set di caratteri per suddividere le stringhe in Split più chiamate al metodo, è consigliabile creare una singola matrice e farvi riferimento in ogni chiamata al metodo.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Questo riduce significativamente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Trim(Char[]) null separator Split(Char[]) In e versioni precedenti, se al metodo viene passato un oggetto che è o non contiene caratteri, il metodo usa un set di caratteri leggermente diverso per suddividere la stringa rispetto al metodo .NET Framework 3.5.NET Framework 3.5 tagliare la stringa.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Suddivide una stringa in un numero massimo di sottostringhe in base ai caratteri in una matrice.Splits a string into a maximum number of substrings based on the characters in an array. Numero massimo di sottostringhe da restituire.You also specify the maximum number of substrings to return.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count);
public string[] Split (char[] separator, int count);
member this.Split : char[] * int -> string[]
Public Function Split (separator As Char(), count As Integer) As String()

Parametri

separator
Char[]

Matrice di caratteri che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32 Int32 Int32 Int32

Numero massimo di sottostringhe da restituire.The maximum number of substrings to return.

Restituisce

String[]

Matrice i cui elementi contengono le sottostringhe in questa istanza delimitate da uno o più caratteri in separator.An array whose elements contain the substrings in this instance that are delimited by one or more characters in separator. Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

Eccezioni

Esempi

Nell'esempio seguente viene illustrato count il modo in cui influiscono sul Splitnumero di stringhe restituite da.The following example demonstrates how count affects the number of strings returned by Split.

string delimStr = " ,.:";
char [] delimiter = delimStr.ToCharArray();
string words = "one two,three:four.";
string [] split = null;

Console.WriteLine("The delimiters are -{0}-", delimStr);
for (int x = 1; x <= 5; x++) 
{
   split = words.Split(delimiter, x);
   Console.WriteLine("\ncount = {0,2} ..............", x);
   foreach (var s in split) 
   {
       Console.WriteLine("-{0}-", s);
   }
}

// The example displays the following output:
//       The delimiters are - ,.:-
//       count =  1 ..............
//       -one two,three:four.-
//       count =  2 ..............
//       -one-
//       -two,three:four.-
//       count =  3 ..............
//       -one-
//       -two-
//       -three:four.-
//       count =  4 ..............
//       -one-
//       -two-
//       -three-
//       -four.-
//       count =  5 ..............
//       -one-
//       -two-
//       -three-
//       -four-
//       --
Public Class StringSplit2
   Public Shared Sub Main()
      
      Dim delimStr As String = " ,.:"
      Dim delimiter As Char() = delimStr.ToCharArray()
      Dim words As String = "one two,three:four."
      Dim split As String() = Nothing
      
      Console.WriteLine("The delimiters are -{0}-", delimStr)
      Dim x As Integer
      For x = 1 To 5
         split = words.Split(delimiter, x)
         Console.WriteLine(ControlChars.Cr + "count = {0,2} ..............", x)
         Dim s As String
         For Each s In  split
            Console.WriteLine("-{0}-", s)
         Next s
      Next x
   End Sub 
End Class 
' The example displays the following output:
'       The delimiters are - ,.:-
'       count =  1 ..............
'       -one two,three:four.-
'       count =  2 ..............
'       -one-
'       -two,three:four.-
'       count =  3 ..............
'       -one-
'       -two-
'       -three:four.-
'       count =  4 ..............
'       -one-
'       -two-
'       -three-
'       -four.-
'       count =  5 ..............
'       -one-
'       -two-
'       -three-
'       -four-
'       --

Commenti

I caratteri delimitatori non sono inclusi negli elementi della matrice restituita.Delimiter characters are not included in the elements of the returned array.

Se questa istanza non contiene alcun carattere in separator, la matrice restituita è costituita da un singolo elemento che contiene questa istanza.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance. Se count è zero, viene restituita una matrice vuota.If count is zero, an empty array is returned.

Se il separator parametro è null o non contiene caratteri, si presuppone che gli spazi vuoti siano i delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti vengono definiti dallo standard Unicode e restituiscono true se vengono passati Char.IsWhiteSpace al metodo.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Ogni elemento di separator definisce un carattere delimitatore separato.Each element of separator defines a separate delimiter character. Se due delimitatori sono adiacenti o un delimitatore viene individuato all'inizio o alla fine di questa istanza, l'elemento della matrice Emptycorrispondente contiene.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Se sono presenti più di count sottostringhe in questa istanza, le prime count sottostringhe meno 1 vengono restituite nei primi count meno 1 elementi del valore restituito e i caratteri rimanenti in questa istanza vengono restituiti negli ultimi elemento del valore restituito.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Se count è maggiore del numero di sottostringhe, vengono restituite le sottostringhe disponibili e non viene generata alcuna eccezione.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Nella tabella seguente vengono forniti esempi.The following table provides examples.

Valore stringaString value SeparatoreSeparator ConteggioCount Matrice restituitaReturned array
"42, 12, 19""42, 12, 19" New Char [] {',',''} (C#)new Char[] {',', ' '} (C#)

Char() = {","c, " "c} (Visual Basic)Char() = {","c, " "c} (Visual Basic)
22 {"42", " 12, 19"}{"42", " 12, 19"}
"42..12..19""42..12..19" nuovo carattere [] {' .'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
44 {"42", "", "12", ".19"}{"42", "", "12", ".19"}
Banana"Banana" nuovo carattere [] {' .'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
22 {"Banana"}{"Banana"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
nuovo carattere [] {} (C#)new Char[] {} (C#)

Char() = {} (Visual Basic)Char() = {} (Visual Basic)
11 {"Darb\nSmarba"} (C#){"Darb\nSmarba"} (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
nuovo carattere [] null (C#)new Char[] null (C#)

Char () = NothingChar() = Nothing
22 {"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
nuovo carattere [] null (C#)new Char[] null (C#)

Char () = NothingChar() = Nothing
100100 {"Darb", "Smarba"}{"Darb", "Smarba"}

Considerazioni sulle prestazioniPerformance Considerations

I Split metodi allocano memoria per l'oggetto matrice restituito e String un oggetto per ogni elemento della matrice.The Split methods allocate memory for the returned array object and a String object for each array element. Se l'applicazione richiede prestazioni ottimali o se la gestione dell'allocazione di memoria è fondamentale nell'applicazione IndexOf , IndexOfAny è consigliabile usare il metodo o Compare e, facoltativamente, il metodo, per individuare una sottostringa all'interno di una stringa.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Se si divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Inoltre, se si usa lo stesso set di caratteri per suddividere le stringhe in Split più chiamate al metodo, è consigliabile creare una singola matrice e farvi riferimento in ogni chiamata al metodo.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Questo riduce significativamente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Trim(Char[]) null separator Split(Char[]) In e versioni precedenti, se al metodo viene passato un oggetto che è o non contiene caratteri, il metodo usa un set di caratteri leggermente diverso per suddividere la stringa rispetto al metodo .NET Framework 3.5.NET Framework 3.5 tagliare la stringa.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Vedi anche

Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)

public string[] Split (char separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * StringSplitOptions -> string[]
Public Function Split (separator As Char, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parametri

separator
Char Char Char Char

Restituisce

String[]

Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)

public string[] Split (string separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * StringSplitOptions -> string[]
Public Function Split (separator As String, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parametri

Restituisce

String[]

Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Suddivide una stringa in sottostringhe basate sui caratteri in una matrice.Splits a string into substrings that are based on the characters in an array.

public:
 cli::array <System::String ^> ^ Split(... cli::array <char> ^ separator);
public string[] Split (params char[] separator);
member this.Split : char[] -> string[]
Public Function Split (ParamArray separator As Char()) As String()

Parametri

separator
Char[]

Matrice di caratteri che delimita le sottostringhe di questa stringa, matrice vuota senza delimitatori o null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

Restituisce

String[]

Matrice i cui elementi contengono le sottostringhe da questa istanza delimitate da uno o più caratteri in separator.An array whose elements contain the substrings from this instance that are delimited by one or more characters in separator. Per altre informazioni, vedere la sezione Osservazioni.For more information, see the Remarks section.

Esempi

Nell'esempio seguente viene illustrato come estrarre singole parole da un blocco di testo trattando gli spazi vuoti e i segni di punteggiatura come delimitatori.The following example demonstrates how to extract individual words from a block of text by treating white space and punctuation marks as delimiters. La matrice di caratteri passata al separator parametro String.Split(Char[]) del metodo è costituita da un carattere spazio e da un carattere di tabulazione, insieme ad alcuni simboli di punteggiatura comuni.The character array passed to the separator parameter of the String.Split(Char[]) method consists of a space character and a tab character, together with some common punctuation symbols.

string words = "This is a list of words, with: a bit of punctuation" +
               "\tand a tab character.";

string [] split = words.Split(new Char [] {' ', ',', '.', ':', '\t' });

foreach (string s in split) 
{

    if (s.Trim() != "")
        Console.WriteLine(s);
}

// The example displays the following output to the console:
//       This
//       is
//       a
//       list
//       of
//       words
//       with
//       a
//       bit
//       of
//       punctuation
//       and
//       a
//       tab
//       character
Public Class SplitTest
    Public Shared Sub Main()
        Dim words As String = "This is a list of words, with: a bit of punctuation" + _
                              vbTab + "and a tab character."
        Dim split As String() = words.Split(New [Char]() {" "c, ","c, "."c, ":"c, CChar(vbTab) })
                
        For Each s As String In  split
            If s.Trim() <> "" Then
                Console.WriteLine(s)
            End If
        Next s
    End Sub
End Class
' The example displays the following output to the console:
'       This
'       is
'       a
'       list
'       of
'       words
'       with
'       a
'       bit
'       of
'       punctuation
'       and
'       a
'       tab
'       character

Commenti

Quando una stringa è delimitata da un set di caratteri noto, è possibile usare il Split(Char[]) metodo per separarlo in sottostringhe.When a string is delimited by a known set of characters, you can use the Split(Char[]) method to separate it into substrings.

Dettagli valore restituitoReturn value details

I caratteri delimitatori non sono inclusi negli elementi della matrice restituita.Delimiter characters are not included in the elements of the returned array. Se, ad esempio, la matrice di separatore include il carattere "-" e il valore dell'istanza di stringa corrente è "AA-BB-CC", il metodo restituisce una matrice che contiene tre elementi: "AA", "BB" e "CC".For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Se questa istanza non contiene alcun carattere in separator, la matrice restituita è costituita da un singolo elemento che contiene questa istanza.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Ogni elemento di separator definisce un carattere delimitatore separato.Each element of separator defines a separate delimiter character. Se due delimitatori sono adiacenti o un delimitatore viene individuato all'inizio o alla fine di questa istanza, l'elemento corrispondente nella matrice restituita Emptycontiene.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding element in the returned array contains Empty. Ecco alcuni esempi:Here are some examples:

Valore stringaString value SeparatoreSeparator Matrice restituitaReturned array
"42, 12, 19""42, 12, 19" New Char [] {',',''} (C#)new Char[] {',', ' '} (C#)

Char() = {","c, " "c}) (Visual Basic)Char() = {","c, " "c}) (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"42..12..19""42..12..19" nuovo carattere [] {' .'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
Banana"Banana" nuovo carattere [] {' .'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"Banana"}{"Banana"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
nuovo carattere [] {} (C#)new Char[] {} (C#)

Char() = {} (Visual Basic)Char() = {} (Visual Basic)
{"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nSmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
null (C#)null (C#)

Nothing (Visual Basic)Nothing (Visual Basic)
{"Darb", "Smarba"}{"Darb", "Smarba"}

Matrice di separatoreThe separator array

Ogni elemento del separatore definisce un delimitatore separato costituito da un singolo carattere.Each element of separator defines a separate delimiter that consists of a single character. Se l' separator argomento è null o non contiene caratteri, il metodo considera gli spazi vuoti come delimitatori.If the separator argument is null or contains no characters, the method treats white-space characters as the delimiters. Gli spazi vuoti sono definiti dallo standard Unicode; restituiscono true se vengono passati Char.IsWhiteSpace al metodo.White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

String. Split (Char []) e risoluzione dell'overload del compilatoreString.Split(Char[]) and compiler overload resolution

Sebbene il singolo parametro per questo overload di String.Split sia una matrice di caratteri, è possibile chiamarlo con un singolo carattere, come illustrato nell'esempio seguente.Although the single parameter for this overload of String.Split is a character array, you can call it with a single character, as the following example shows.

String value = "This is a short string.";
Char delimiter = 's';
String[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
   Console.WriteLine(substring);
// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.
Module Example
   Public Sub Main()
      Dim value As String = "This is a short string."
      Dim delimiter As Char = "s"c
      Dim substrings() As String = value.Split(delimiter)
      For Each substring In substrings
         Console.WriteLine(substring)
      Next
   End Sub
End Module
' The example displays the following output:
'     Thi
'      i
'      a
'     hort
'     tring.

Poiché il separator parametro è decorato con ParamArrayAttribute l'attributo, i compilatori interpretano un singolo carattere come matrice di caratteri a elemento singolo.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. Questo non avviene per altri String.Split overload che includono un separator parametro. è necessario passare in modo esplicito questi overload separator a una matrice di caratteri come argomento.This is not the case for other String.Split overloads that include a separator parameter; you must explicitly pass these overloads a character array as the separator argument.

Dettagli confrontoComparison details

Il Split(Char[]) metodo estrae le sottostringhe di questa stringa delimitate da uno o più caratteri separator nella matrice e restituisce tali sottostringhe come elementi di una matrice.The Split(Char[]) method extracts the substrings in this string that are delimited by one or more of the characters in the separator array, and returns those substrings as elements of an array.

Il Split(Char[]) metodo cerca i delimitatori eseguendo confronti usando le regole di ordinamento ordinali con distinzione tra maiuscole e minuscole.The Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per ulteriori informazioni sugli ordinamenti di Word, stringa e ordinali, System.Globalization.CompareOptions vedere l'enumerazione.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considerazioni sulle prestazioniPerformance Considerations

I Split metodi allocano memoria per l'oggetto matrice restituito e String un oggetto per ogni elemento della matrice.The Split methods allocate memory for the returned array object and a String object for each array element. Se l'applicazione richiede prestazioni ottimali o se la gestione dell'allocazione di memoria è fondamentale nell'applicazione IndexOf , IndexOfAny è consigliabile usare il metodo o.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. È anche possibile usare il Compare metodo per individuare una sottostringa all'interno di una stringa.You also have the option of using the Compare method to locate a substring within a string.

Per suddividere una stringa in corrispondenza di un carattere separatore IndexOfAny , utilizzare il IndexOf metodo o per individuare un carattere separatore nella stringa.To split a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Per suddividere una stringa in corrispondenza di una stringa separatore IndexOfAny , utilizzare il IndexOf metodo o per individuare il primo carattere della stringa di separazione.To split a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Inoltre, se si usa lo stesso set di caratteri per suddividere le stringhe in Split più chiamate al metodo, è consigliabile creare una singola matrice e farvi riferimento in ogni chiamata al metodo.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Questo riduce significativamente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Trim(Char[]) null separator Split(Char[]) In e versioni precedenti, se al metodo viene passato un oggetto che è o non contiene caratteri, il metodo usa un set di caratteri leggermente diverso per suddividere la stringa rispetto al metodo .NET Framework 3.5.NET Framework 3.5 tagliare la stringa.In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Vedi anche

Si applica a