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

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

Commenti

Split viene usato per suddividere una stringa delimitata in sottostringhe.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, uno 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 restituito dal metodo (il Split(Char[], Int32) metodo), per determinare se le stringhe vuote vengono incluse nelle sottostringhe restituite (il Split(Char[], StringSplitOptions) e Split(String[], StringSplitOptions) metodi, o eseguire entrambe le operazioni (il Split(Char[], Int32, StringSplitOptions) e Split(String[], Int32, StringSplitOptions) metodi).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 vuole estrarre tutte le sottostringhe di una stringa delimitata o se si desidera analizzare una stringa in base a un modello anziché un set di caratteri di delimitazione, prendere in considerazione 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 conforme a un modello predefinito, è 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. Ad esempio, se le stringhe hanno il formato "numero operando numero" è possibile usare un espressione regolare per estrarre e gestire il 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:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      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 (Match m in 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

Criterio di espressione regolare (\d+)\s+([-+*/])\s+(\d+) è definito nel modo seguente:The regular expression pattern (\d+)\s+([-+*/])\s+(\d+) is defined like this:

ModelloPattern DescrizioneDescription
(\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ù caratteri spazio vuoto.Match one or more white-space characters.
([-+*/]) Corrisponde un segno di operatori aritmetici (+, -, *, 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ù caratteri spazio vuoto.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é 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. Quando una di queste condizioni si verifica, questo è uno scenario comune:This is a common scenario when either of these conditions occurs:

  • Uno o più caratteri delimitatori non sempre fungere da un delimitatore di 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 di delimitazione è variabile o sconosciuto.The sequence and number of delimiter characters is variable or unknown.

Ad esempio, il Split metodo non può essere usato per suddividere la stringa seguente, perché il numero di \n (in c#) o vbCrLf (in Visual Basic) di caratteri è variabile, e non sempre fungono 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 di questa stringa è possibile suddividere facilmente, come illustrato nell'esempio seguente.A regular expression can split this string easily, as the following example shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      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 (Match m in 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.

Criterio di espressione regolare \[([^\[\]]+)\] è definito nel modo seguente:The regular expression pattern \[([^\[\]]+)\] is defined like this:

ModelloPattern DescrizioneDescription
\[ Corrisponde a una parentesi quadra aperta.Match an opening bracket.
([^\[\]]+) Corrisponde a qualsiasi carattere che non è una parentesi o una parentesi 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 è quasi identico al metodo String.Split, ad eccezione del fatto che suddivide una stringa in base a un criterio di espressione regolare invece di un set di caratteri predefinito.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, l'esempio seguente usa il Regex.Split metodo per suddividere una stringa che contiene le sottostringhe delimitate da varie 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.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String input = "abacus -- alabaster - * - atrium -+- " +
                     "any -*- actual - + - armoir - - alarm";
      String pattern = @"\s-\s?[+*]?\s?-\s";
      String[] elements = Regex.Split(input, pattern);
      foreach (var element in elements)
         Console.WriteLine(element);
   }
}
// The example displays the following output:
//       abacus
//       alabaster
//       atrium
//       any
//       actual
//       armoir
//       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

Criterio di espressione regolare \s-\s?[+*]?\s?-\s è definito nel modo seguente:The regular expression pattern \s-\s?[+*]?\s?-\s is defined like this:

ModelloPattern DescrizioneDescription
\s- Corrisponde a un carattere di 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.
[+*]? Corrisponde a zero o una occorrenza di uno il + o * carattere.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 seguita da un carattere di spazio vuoto.Match a hyphen followed by a white-space character.

I metodi di ricerca e il metodo SubstringSearch methods and the Substring method

Se non si è interessati a tutte le sottostringhe in 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 da.You can then call the Substring method to extract the substring that you want. I metodi di confronto di stringhe includono:The string comparison methods include:

  • IndexOf, che restituisce l'indice in base zero della prima occorrenza di un carattere o stringa in un'istanza di stringa., 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 della stringa corrente della prima occorrenza di qualsiasi carattere in una matrice di caratteri., 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 stringa in un'istanza di stringa., 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 della stringa corrente dell'ultima occorrenza di qualsiasi carattere in una matrice di caratteri., which returns a zero-based index in the current string instance of the last occurrence of any character in a character array.

L'esempio seguente usa il IndexOf metodo per individuare i periodi in una stringa.The following example uses the IndexOf method to find the periods in a string. Usa quindi il Substring metodo a restituire frasi intere.It then uses the Substring method to return full sentences.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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(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 gli elementi.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

Esempi

L'esempio seguente usa il StringSplitOptions enumerazione da includere o escludere le sottostringhe generate dal Split (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.
using System;

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

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

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

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

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

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

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

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

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

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

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

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

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

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Imports System

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 'Main
    
    
    ' 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 'Show
End Class 'Sample
'
'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 del valore restituitoReturn value details

Stringhe del delimitatore non sono inclusi gli elementi della matrice restituita.Delimiter strings are not included in the elements of the returned array.

Se questa istanza non contiene una delle stringhe nelle separator, o count parametro è 1, la matrice restituita è costituito 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, gli spazi vuoti vengono considerati come delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti sono definiti dallo standard Unicode e ritorno true se vengono passati al Char.IsWhiteSpace (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, si verifica un errore di risoluzione dell'overload del compilatore.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Per identificare in modo non ambiguo il metodo chiamato, il codice deve indicare il tipo del null.To unambiguously identify the called method, your code must indicate the type of the null. Nell'esempio seguente vengono illustrati diversi modi per identificarlo 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 è uguale a zero, o il options parametro è RemoveEmptyEntries e la lunghezza di questa istanza è uguale a 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 della separator definisce un delimitatore separato che è 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 i delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento corrispondente della matrice contiene Empty.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 di questa istanza, il primo count -1 sottostringhe vengono restituiti nel primo count -1 elementi del valore restituito e i caratteri rimanenti in questa istanza, vengono restituiti nell'ultimo 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 disponibile e 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, la sottostringa intera 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", provare a suddividere 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: {"This", "is", "a", "string".returns this four-element array: { "This", "is", "a", "string." }.}.

Dettagli relativi al confrontoComparison details

Il Split metodo consente di estrarre le sottostringhe di questa stringa delimitate da uno o più delle stringhe di separator parametro e restituisce le 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 mediante l'esecuzione di confronti con le regole di ordinamento per ordinale tra maiuscole e minuscole.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per altre informazioni sui word, la stringa e gli ordinamenti ordinale, vedere il System.Globalization.CompareOptions enumerazione.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

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

Per evitare risultati ambigui quando le stringhe nella separator hanno in comune, caratteri il Split metodo consente di passare dall'inizio alla fine del valore dell'istanza e corrisponde al primo elemento di separator uguale al delimitatore nella 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 si verificano nell'istanza ha la precedenza sull'ordine degli elementi in separator.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 era "ef" e il secondo elemento è stato "bcde", il risultato dell'operazione split sarebbe "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ò avviene perché la sottostringa dell'istanza, "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 è stato "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 accade perché "bcd" è il primo delimitatore individuato 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 è stato annullato. l'ordine dei separatori di "bc" è stato il primo elemento e il secondo elemento è stato "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

Il Split metodi di allocano della memoria per l'oggetto matrice restituito e un String 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 per l'applicazione, è consigliabile usare il IndexOf oppure IndexOfAny metodo e, facoltativamente, il Compare (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 suddivide una stringa in corrispondenza di un carattere separatore, usare il IndexOf o IndexOfAny metodo 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 suddivide una stringa in una stringa di separazione, usare il IndexOf o IndexOfAny metodo 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 per i restanti caratteri 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 lo stesso set di caratteri viene usato per suddividere le stringhe in più Split chiamate al metodo, prendere in considerazione la creazione di una 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 notevolmente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Nel .NET Framework 3.5.NET Framework 3.5 e versioni precedenti, se il Split(Char[]) viene passato un separator vale a dire null o non contiene caratteri, il metodo Usa un set di caratteri leggermente diverso per suddividere la stringa che il Trim(Char[]) metodo esegue un' Taglia 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 spazi vuoti 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[], 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 gli elementi.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

Esempi

L'esempio seguente usa il StringSplitOptions enumerazione da includere o escludere le sottostringhe generate dal Split (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.
using System;

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

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

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

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

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

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

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

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

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

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

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

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

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

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Imports System

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 'Main
    
    
    ' 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 'Show
End Class 'Sample
'
'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

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

Se questa istanza non contiene i caratteri in separator, o count parametro è 1, la matrice restituita è costituito 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, gli spazi vuoti vengono considerati come delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti sono definiti dallo standard Unicode e ritorno true se vengono passati al Char.IsWhiteSpace (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, si verifica un errore di risoluzione dell'overload del compilatore.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Per identificare in modo non ambiguo 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 identificarlo 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 è uguale a zero, o il options parametro è RemoveEmptyEntries e la lunghezza di questa istanza è uguale a 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 della separator definisce un carattere di delimitazione separato.Each element of separator defines a separate delimiter character. Se il options parametro è Nonee due i delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento corrispondente della matrice contiene Empty.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 di questa istanza, il primo count -1 sottostringhe vengono restituiti nel primo count -1 elementi del valore restituito e i caratteri rimanenti in questa istanza, vengono restituiti nell'ultimo 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 disponibile e 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

Il Split metodi di allocano della memoria per l'oggetto matrice restituito e un String 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 per l'applicazione, è consigliabile usare il IndexOf oppure IndexOfAny metodo e, facoltativamente, il Compare (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 suddivide una stringa in corrispondenza di un carattere separatore, usare il IndexOf o IndexOfAny metodo 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 suddivide una stringa in una stringa di separazione, usare il IndexOf o IndexOfAny metodo 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 per i restanti caratteri 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 lo stesso set di caratteri viene usato per suddividere le stringhe in più Split chiamate al metodo, prendere in considerazione la creazione di una 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 notevolmente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Nel .NET Framework 3.5.NET Framework 3.5 e versioni precedenti, se il Split(Char[]) viene passato un separator vale a dire null o non contiene caratteri, il metodo Usa un set di caratteri leggermente diverso per suddividere la stringa che il Trim(Char[]) metodo esegue un' Taglia 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 spazi vuoti 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[], 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 gli elementi.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

Esempi

L'esempio seguente illustra la differenza tra le matrici restituite mediante una chiamata di una stringa String.Split(String[], StringSplitOptions) metodo con relativo options uguale al parametro StringSplitOptions.None e StringSplitOptions.RemoveEmptyEntries.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.

using System;

class Example 
{
   public static void Main() 
   {
      string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
      string[] stringSeparators = new string[] {"[stop]"};
      string[] result;
      
      // Display the original string and delimiter string.
      Console.WriteLine("Splitting the string:\n   \"{0}\".", source);
      Console.WriteLine();
      Console.WriteLine("Using the delimiter string:\n   \"{0}\"", 
                        stringSeparators[0]);
      Console.WriteLine();                           
         
      // Split a string delimited by another string and return all elements.
      result = source.Split(stringSeparators, StringSplitOptions.None);
      Console.WriteLine("Result including all elements ({0} elements):", 
                        result.Length);
      Console.Write("   ");
      foreach (string s in result)
      {
         Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
      }
      Console.WriteLine();
      Console.WriteLine();

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

L'esempio seguente definisce una matrice di separatori che includono segni di punteggiatura e caratteri di spazio.The following example defines an array of separators that include punctuation and white-space characters. Il passaggio di questa matrice insieme a un valore di StringSplitOptions.RemoveEmptyEntries per il Split(String[], StringSplitOptions) metodo restituisce una matrice costituita da singole parole dalla stringa.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.

using System;

public class Example
{
   public static void Main()
   {
      string[] separators = {",", ".", "!", "?", ";", ":", " "};
      string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
      string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
      foreach (var word in words)
         Console.WriteLine(word);
   }
}
// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate
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 il options argomento impostato su StringSplitOptions.RemoveEmptyEntries.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. Ciò impedisce la matrice restituita inclusi String.Empty valori che rappresentano corrispondenze di sottostringhe vuota tra segni di punteggiatura e caratteri di spazio.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 noto di stringhe, è 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 del valore restituitoReturn value details

Stringhe del delimitatore non sono inclusi gli elementi della matrice restituita.Delimiter strings are not included in the elements of the returned array. Ad esempio, se il separator matrice include la stringa "-" e il valore dell'istanza della stringa corrente è "aa - bb-cc", il metodo restituisce una matrice che contiene tre elementi: "aa", "bb" e "cc".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 una delle stringhe in separator, la matrice restituita è costituito 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 è uguale a 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 della separator definisce un delimitatore separato che è costituito da uno o più caratteri.Each element of separator defines a separate delimiter that consists of one or more characters. Se il options argomento è Nonee due i delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento corrispondente della matrice contiene String.Empty.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. Ad esempio, se separator include due elementi, "-" e "_", il valore dell'istanza della stringa è "-_aa -_" e il valore della options argomento è None, il metodo restituisce una matrice di stringa i seguenti cinque elementi: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 una stringa vuota che precede la "-" sottostringa in corrispondenza dell'indice 0., which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty, che rappresenta una stringa vuota tra le "-" sottostringa in corrispondenza dell'indice 0 e la sottostringa "" in corrispondenza dell'indice 1., 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 una stringa vuota che segue la sottostringa "" in corrispondenza dell'indice 4., which represents the empty string that follows the "" substring at index 4.

  5. String.Empty, che rappresenta una stringa vuota che segue il "-" sottostringa in corrispondenza dell'indice 5., 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, la sottostringa intera 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", provare a suddividere 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, gli spazi vuoti vengono considerati come delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti sono definiti dallo standard Unicode e ritorno true se vengono passati al Char.IsWhiteSpace (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, si verifica un errore di risoluzione dell'overload del compilatore.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Per identificare in modo non ambiguo il metodo chiamato, il codice deve indicare il tipo del null.To unambiguously identify the called method, your code must indicate the type of the null. Nell'esempio seguente vengono illustrati diversi modi per identificarlo 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 relativi al confrontoComparison details

Il Split metodo consente di estrarre le sottostringhe di questa stringa delimitate da uno o più delle stringhe di separator parametro e restituisce le 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 mediante l'esecuzione di confronti con le regole di ordinamento per ordinale tra maiuscole e minuscole.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per altre informazioni sui word, la stringa e gli ordinamenti ordinale, vedere il System.Globalization.CompareOptions enumerazione.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

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

Per evitare risultati ambigui quando le stringhe nella separator hanno in comune, i caratteri la Split operazione procede a partire dall'inizio alla fine del valore dell'istanza e corrisponde al primo elemento di separator uguale al 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 si verificano nell'istanza ha la precedenza sull'ordine degli elementi in separator.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 era "ef" e il secondo elemento è stato "bcde", il risultato dell'operazione split sarebbe 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ò avviene perché la sottostringa dell'istanza, "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 è stato "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 accade perché "bcd" è il primo delimitatore individuato 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 è stato annullato. l'ordine dei separatori di "bc" è stato il primo elemento e il secondo elemento è stato "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

Il Split metodi di allocano della memoria per l'oggetto matrice restituito e un String 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 per l'applicazione, è consigliabile usare il IndexOf oppure IndexOfAny metodo e, facoltativamente, il Compare (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 suddivide una stringa in corrispondenza di un carattere separatore, usare il IndexOf o IndexOfAny metodo 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 suddivide una stringa in una stringa di separazione, usare il IndexOf o IndexOfAny metodo 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 per i restanti caratteri 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 lo stesso set di caratteri viene usato per suddividere le stringhe in più Split chiamate al metodo, prendere in considerazione la creazione di una 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 notevolmente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Nel .NET Framework 3.5.NET Framework 3.5 e versioni precedenti, se il Split(Char[]) viene passato un separator vale a dire null o non contiene caratteri, il metodo Usa un set di caratteri leggermente diverso per suddividere la stringa che il Trim(Char[]) metodo esegue un' Taglia 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 spazi vuoti Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

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(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 gli elementi.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

Esempi

L'esempio seguente usa il StringSplitOptions enumerazione da includere o escludere le sottostringhe generate dal Split (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.
using System;

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

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

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

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

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

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

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

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

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

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

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

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

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

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Imports System

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 'Main
    
    
    ' 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 'Show
End Class 'Sample
'
'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 del valore restituitoReturn value details

Caratteri di delimitazione (i caratteri di separator matrice) non sono inclusi gli elementi della matrice restituita.Delimiter characters (the characters in the separator array) are not included in the elements of the returned array. Ad esempio, se il separator matrice include il carattere "-" e il valore dell'istanza della 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 i caratteri in separator, la matrice restituita è costituito 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 è uguale a 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 della separator definisce un delimitatore separato che è costituito da un singolo carattere.Each element of separator defines a separate delimiter that consists of a single character. Se il options argomento è Nonee due i delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento corrispondente della matrice contiene String.Empty.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. Ad esempio, se separator include due elementi, "-" e "_", il valore dell'istanza della stringa è "-_aa -_" e il valore della options argomento è None, il metodo restituisce una matrice di stringhe con i seguenti cinque elementi: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 una stringa vuota che precede la "-" carattere in corrispondenza dell'indice 0., which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty, che rappresenta una stringa vuota tra le "-" carattere in corrispondenza dell'indice 0 e il carattere "" in corrispondenza dell'indice 1., 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 una stringa vuota che segue il carattere "" in corrispondenza dell'indice 4., which represents the empty string that follows the "" character at index 4.

  5. String.Empty, che rappresenta una stringa vuota che segue il "-" carattere in corrispondenza dell'indice 5., 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, gli spazi vuoti vengono considerati come delimitatori.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Gli spazi vuoti sono definiti dallo standard Unicode e ritorno true se vengono passati al Char.IsWhiteSpace (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, si verifica un errore di risoluzione dell'overload del compilatore.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Per identificare in modo non ambiguo il metodo chiamato, il codice deve indicare il tipo del null.To unambiguously identify the called method, your code must indicate the type of the null. Nell'esempio seguente vengono illustrati diversi modi per identificarlo 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 relativi al confrontoComparison details

Il Split metodo consente di estrarre le sottostringhe di questa stringa delimitate da uno o più dei caratteri di separator parametro e restituisce le 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 mediante l'esecuzione di confronti con le regole di ordinamento per ordinale tra maiuscole e minuscole.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per altre informazioni sui word, la stringa e gli ordinamenti ordinale, vedere il System.Globalization.CompareOptions enumerazione.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considerazioni sulle prestazioniPerformance Considerations

Il Split metodi di allocano della memoria per l'oggetto matrice restituito e un String 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 per l'applicazione, è consigliabile usare il IndexOf oppure IndexOfAny metodo e, facoltativamente, il Compare (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 suddivide una stringa in corrispondenza di un carattere separatore, usare il IndexOf o IndexOfAny metodo 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 suddivide una stringa in una stringa di separazione, usare il IndexOf o IndexOfAny metodo 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 per i restanti caratteri 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 lo stesso set di caratteri viene usato per suddividere le stringhe in più Split chiamate al metodo, prendere in considerazione la creazione di una 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 notevolmente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Nel .NET Framework 3.5.NET Framework 3.5 e versioni precedenti, se il Split(Char[]) viene passato un separator vale a dire null o non contiene caratteri, il metodo Usa un set di caratteri leggermente diverso per suddividere la stringa che il Trim(Char[]) metodo esegue un' Taglia 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 spazi vuoti 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 come count influisce sul numero delle stringe restituite dalle Split.The following example demonstrates how count affects the number of strings returned by Split.

using System;

public class Example
{
   public static void Main() 
   {
      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

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

Se questa istanza non contiene i caratteri in separator, la matrice restituita è costituito 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 è uguale a zero, viene restituita una matrice vuota.If count is zero, an empty array is returned.

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

Ogni elemento della separator definisce un carattere di delimitazione separato.Each element of separator defines a separate delimiter character. Se due i delimitatori sono adiacenti o all'inizio o alla fine di questa istanza viene trovato un delimitatore, l'elemento corrispondente della matrice contiene Empty.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 di questa istanza, il primo count -1 sottostringhe vengono restituiti nel primo count -1 elementi del valore restituito e i caratteri rimanenti in questa istanza, vengono restituiti nell'ultimo 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 disponibile e 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 Char [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
44 {"42", "", "12", ".19"}{"42", "", "12", ".19"}
"Banana""Banana" nuovo Char [] {'. '}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)
new Char[] {} (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] Char 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] Char null (C#)new Char[] null (C#)

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

Considerazioni sulle prestazioniPerformance Considerations

Il Split metodi di allocano della memoria per l'oggetto matrice restituito e un String 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 per l'applicazione, è consigliabile usare il IndexOf oppure IndexOfAny metodo e, facoltativamente, il Compare (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 suddivide una stringa in corrispondenza di un carattere separatore, usare il IndexOf o IndexOfAny metodo 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 suddivide una stringa in una stringa di separazione, usare il IndexOf o IndexOfAny metodo 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 per i restanti caratteri 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 lo stesso set di caratteri viene usato per suddividere le stringhe in più Split chiamate al metodo, prendere in considerazione la creazione di una 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 notevolmente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Nel .NET Framework 3.5.NET Framework 3.5 e versioni precedenti, se il Split(Char[]) viene passato un separator vale a dire null o non contiene caratteri, il metodo Usa un set di caratteri leggermente diverso per suddividere la stringa che il Trim(Char[]) metodo esegue un' Taglia 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 spazi vuoti Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Vedi anche

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, considerando gli spazi vuoti e 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 per la separator parametro del String.Split(Char[]) metodo è costituito da un carattere di spazio e un carattere di tabulazione, con 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.

using System;

public class SplitTest {
    public static void Main() {

        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 'Main
End Class 'SplitTest
' 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 del valore restituitoReturn value details

Caratteri delimitatori non sono inclusi gli elementi della matrice restituita.Delimiter characters are not included in the elements of the returned array. Ad esempio, se la matrice separatore include il carattere "-" e il valore dell'istanza della 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 i caratteri in separator, la matrice restituita è costituito 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 della separator definisce un carattere di delimitazione separato.Each element of separator defines a separate delimiter character. Se due i delimitatori sono adiacenti o all'inizio o alla fine di questa istanza viene trovato un delimitatore, l'elemento corrispondente nella matrice restituita contiene Empty.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 Char [] {'. '}new Char[] {'.'} (C#)(C#)

Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"Banana""Banana" nuovo Char [] {'. '}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)
new Char[] {} (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 che è costituito da un singolo carattere.Each element of separator defines a separate delimiter that consists of a single character. Se il 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 da Unicode standard; restituiscono true se vengono passati al Char.IsWhiteSpace (metodo).White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

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

Anche se il singolo parametro per questo overload del metodo String.Split è una matrice di caratteri, è possibile chiamare 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.

using System;

public class Example
{
   public static void Main()
   {
      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 il ParamArrayAttribute attributo, i compilatori interpreterà un singolo carattere come una 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. Ciò non avviene per altri String.Split overload che includono una separator parametro; è necessario passare in modo esplicito questi overload una matrice di caratteri come il separator 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 relativi al confrontoComparison details

Il Split(Char[]) metodo consente di estrarre le sottostringhe di questa stringa delimitate da uno o più dei caratteri di separator della matrice e restituisce le 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 mediante l'esecuzione di confronti con le regole di ordinamento per ordinale tra maiuscole e minuscole.The Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per altre informazioni sui word, la stringa e gli ordinamenti ordinale, vedere il System.Globalization.CompareOptions enumerazione.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Considerazioni sulle prestazioniPerformance Considerations

Il Split metodi di allocano della memoria per l'oggetto matrice restituito e un String 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 per l'applicazione, è consigliabile usare la IndexOf o IndexOfAny (metodo).If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. Hai anche la possibilità di 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, usare il IndexOf o IndexOfAny metodo 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 una stringa di separazione, usare il IndexOf o IndexOfAny metodo 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 per i restanti caratteri 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 lo stesso set di caratteri viene usato per suddividere le stringhe in più Split chiamate al metodo, prendere in considerazione la creazione di una 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 notevolmente l'overhead aggiuntivo di ogni chiamata al metodo.This significantly reduces the additional overhead of each method call.

Note per i chiamanti

Nel .NET Framework 3.5.NET Framework 3.5 e versioni precedenti, se il Split(Char[]) viene passato un separator vale a dire null o non contiene caratteri, il metodo Usa un set di caratteri leggermente diverso per suddividere la stringa che il Trim(Char[]) metodo esegue un' Taglia 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 spazi vuoti Unicode.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Vedi anche

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

Si applica a