String.Split Metodo

Definizione

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

Overload

Split(Char[], Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base ai caratteri di delimitazione specificati e, facoltativamente, ad altre opzioni.Splits a string into a maximum number of substrings based on specified delimiting characters and, optionally, options.

Split(Char, Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base al carattere di delimitazione specificato e, facoltativamente, ad altre opzioni.Splits a string into a maximum number of substrings based on a specified delimiting character and, optionally, options. Divide una stringa in un numero massimo di sottostringhe in base al separatore di caratteri specificato, omettendo facoltativamente le sottostringhe vuote dal risultato.Splits a string into a maximum number of substrings based on the provided character separator, optionally omitting empty substrings from the result.

Split(String[], Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base alle stringhe di delimitazione specificate e, facoltativamente, ad altre opzioni.Splits a string into a maximum number of substrings based on specified delimiting strings and, optionally, options.

Split(String[], StringSplitOptions)

Divide una stringa in sottostringhe in base a una stringa di delimitazione specificata e, facoltativamente, ad altre opzioni.Splits a string into substrings based on a specified delimiting string and, optionally, options.

Split(String, Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base a una stringa di delimitazione specificata e, facoltativamente, ad altre opzioni.Splits a string into a maximum number of substrings based on a specified delimiting string and, optionally, options.

Split(Char[], StringSplitOptions)

Divide una stringa in sottostringhe in base ai caratteri di delimitazione specificati e ad altre opzioni.Splits a string into substrings based on specified delimiting characters and options.

Split(Char[], Int32)

Divide una stringa in un numero massimo di sottostringhe in base ai caratteri di delimitazione specificati.Splits a string into a maximum number of substrings based on specified delimiting characters.

Split(Char, StringSplitOptions)

Divide una stringa in sottostringhe in base al carattere di delimitazione specificato e, facoltativamente, ad altre opzioni.Splits a string into substrings based on a specified delimiting character and, optionally, options.

Split(String, StringSplitOptions)

Suddivide una stringa in sottostringhe in base al separatore di stringa specificato.Splits a string into substrings that are based on the provided string separator.

Split(Char[])

Divide una stringa in sottostringhe in base ai caratteri di delimitazione specificati.Splits a string into substrings based on specified delimiting characters.

Commenti

Split viene usato per suddividere una stringa delimitata in sottostringhe.Split is used to break a delimited string into substrings. È possibile usare una matrice di caratteri o una matrice di stringhe per specificare zero o più caratteri o stringhe di delimitazione.You can use either a character array or a string array to specify zero or more delimiting characters or strings. Se non viene specificato alcun carattere di delimitazione, la stringa viene suddivisa in caratteri di spazio vuoto.If no delimiting characters are specified, the string is split at white-space characters.

Gli overload del Split metodo consentono di limitare il numero di sottostringhe restituite dal metodo ( Split(Char[], Int32) metodo), per specificare se includere stringhe vuote e/o ritagliare le sottostringhe nel risultato ( Split(Char[], StringSplitOptions) Split(String[], StringSplitOptions) metodi e) oppure per eseguire entrambe le operazioni (i Split(Char[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) metodi e).Overloads of the Split method allow you to limit the number of substrings returned by the method (the Split(Char[], Int32) method), to specify whether to include empty strings and/or trim substrings in the result (the Split(Char[], StringSplitOptions) and Split(String[], StringSplitOptions) methods), or to do both (the Split(Char[], Int32, StringSplitOptions) and Split(String[], Int32, StringSplitOptions) methods).

Suggerimento

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 vuole analizzare una stringa basata su un modello anziché un set di caratteri delimitatori, provare a usare espressioni regolari o combinare uno dei metodi di ricerca che restituisce l'indice di un carattere con il Substring metodo.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 using regular expressions, or combine one of the search methods that returns the index of a character with the Substring method. Per altre informazioni, vedere estrarre le sottostringhe da una stringa.For more information, see Extract substrings from a string.

EsempioExample

Negli esempi seguenti vengono illustrati tre overload diversi di String.Split() .The following examples show three different overloads of String.Split(). Nel primo esempio viene chiamato l' Split(Char[]) Overload e viene passato un singolo delimitatore.The first example calls the Split(Char[]) overload and passes in a single delimiter.

string s = "You win some. You lose some.";

string[] subs = s.Split(' ');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.
Dim s As String = "You win some. You lose some."
Dim subs As String() = s.Split()

For Each substring As String In subs
    Console.WriteLine($"Substring: {substring}")
Next

' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some.
' Substring: You
' Substring: lose
' Substring: some.

Come si può notare, i caratteri punto ( . ) sono inclusi in due sottostringhe.As you can see, the period characters (.) are included in two of the substrings. Se si desidera escludere i caratteri del periodo, è possibile aggiungere il carattere punto come carattere di delimitazione aggiuntivo.If you want to exclude the period characters, you can add the period character as an additional delimiting character. Nell'esempio seguente viene illustrato come eseguire questa operazione.The next example shows how to do this.

string s = "You win some. You lose some.";

string[] subs = s.Split(' ', '.');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:
Dim s As String = "You win some. You lose some."
Dim subs As String() = s.Split(" "c, "."c)

For Each substring As String In subs
    Console.WriteLine($"Substring: {substring}")
Next

' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some
' Substring:
' Substring: You
' Substring: lose
' Substring: some
' Substring:

I punti sono passati dalle sottostringhe, ma ora sono state incluse due sottostringhe vuote aggiuntive.The periods are gone from the substrings, but now two extra empty substrings have been included. Questa sottostringa vuota rappresenta la sottostringa tra una parola e il periodo successivo.These empty substring represent the substring between a word and the period that follows it. Per omettere le sottostringhe vuote dalla matrice risultante, è possibile chiamare l' Split(Char[], StringSplitOptions) Overload e specificare StringSplitOptions.RemoveEmptyEntries per il options parametro.To omit empty substrings from the resulting array, you can call the Split(Char[], StringSplitOptions) overload and specify StringSplitOptions.RemoveEmptyEntries for the options parameter.

string s = "You win some. You lose some.";
char[] separators = new char[] { ' ', '.' };

string[] subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some
Dim s As String = "You win some. You lose some."
Dim separators As Char() = New Char() {" "c, "."c}
Dim subs As String() = s.Split(separators, StringSplitOptions.RemoveEmptyEntries)

For Each substring As String In subs
    Console.WriteLine($"Substring: {substring}")
Next

' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some
' Substring: You
' Substring: lose
' Substring: some

Le sezioni relative ai singoli overload di String.Split() contengono ulteriori esempi.The sections for the individual overloads of String.Split() contain further examples.

Split(Char[], Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base ai caratteri di delimitazione specificati e, facoltativamente, ad altre opzioni.Splits a string into a maximum number of substrings based on specified delimiting characters and, optionally, options.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count, StringSplitOptions options);
public string[] Split (char[] separator, int count, StringSplitOptions options);
public string[] Split (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[]
[<System.Runtime.InteropServices.ComVisible(false)>]
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 delimitano le sottostringhe in questa stringa, matrice vuota senza delimitatori o null.An array of characters that delimit the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

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

options
StringSplitOptions

Combinazione bit per bit dei valori di enumerazione, che specifica se tagliare le sottostringhe e includere le sottostringhe vuote.A bitwise combination of the enumeration values that specifies whether to trim substrings and include empty substrings.

Restituisce

String[]

Matrice che contiene le sottostringhe in questa stringa delimitate da uno o più caratteri in separator.An array that contains 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.

Attributi

Eccezioni

count è negativo.count is negative.

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

Esempio

Nell'esempio seguente viene usata l' StringSplitOptions enumerazione per includere o escludere 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.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

// 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 \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

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

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

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

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

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{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]>

*/
    Dim s1 As String = ",ONE,,TWO,,,THREE,,"
    Dim s2 As String = "[stop]" &
                       "ONE[stop][stop]" &
                       "TWO[stop][stop][stop]" &
                       "THREE[stop][stop]"
    Dim charSeparators() As Char = {","c}
    Dim stringSeparators() As String = {"[stop]"}
    Dim result() As String
    ' ------------------------------------------------------------------------------
    ' Split a string delimited by characters.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    ' Display the original string and delimiter characters.
    Console.WriteLine("1a) The original string is ""{0}"".", s1)
    Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))

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

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

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

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

    ' ------------------------------------------------------------------------------
    ' Split a string delimited by another string.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)

    ' Display the original string and delimiter string.
    Console.WriteLine("2a) The original string is ""{0}"".", s2)
    Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))

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

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

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

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

End Sub


' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
    Console.WriteLine("The return value contains these {0} elements:", entries.Length)
    Dim entry As String
    For Each entry In entries
        Console.Write("<{0}>", entry)
    Next entry
    Console.Write(vbCrLf & vbCrLf)

End Sub

'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a) The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Commenti

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

Se questa istanza non contiene caratteri in separator o se il count parametro è 1, la matrice restituita è costituita da un singolo elemento che contiene questa istanza.If this instance does not contain any of the characters in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance.

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

Per passare null per il char[] separator parametro, è necessario indicare il tipo di null per distinguere la chiamata da altri overload, ad esempio Split(String[], Int32, StringSplitOptions) .To pass null for the char[] separator parameter, you must indicate the type of the null to disambiguate the call from some other overloads, such as Split(String[], Int32, StringSplitOptions). Nell'esempio seguente vengono illustrati diversi modi per identificare in modo univoco questo overload.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";

_ = phrase.Split(default(char[]), 3, StringSplitOptions.RemoveEmptyEntries);

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

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

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

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

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

Ogni elemento di separator definisce un carattere delimitatore separato.Each element of separator defines a separate delimiter character. Se il options parametro è None e due delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente 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 in questa istanza, le prime count sottostringhe meno 1 vengono restituite nei primi count meno 1 elementi del valore restituito e i caratteri rimanenti in questa istanza vengono restituiti 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 disponibili e non viene generata alcuna eccezione.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Considerazioni sulle prestazioniPerformance considerations

I Split Metodi allocano memoria per l'oggetto matrice restituito e 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 nell'applicazione, è consigliabile usare il IndexOf IndexOfAny metodo o 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 divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

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

Note per i chiamanti

In .NET Framework 3,5 e versioni precedenti, se al Split(Char[]) metodo viene passato un oggetto separator che è null o non contiene caratteri, il metodo usa un set leggermente diverso di spazi vuoti per suddividere la stringa rispetto al Trim(Char[]) metodo per tagliare la stringa.In .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 white-space characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Si applica a

Split(Char, Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base al carattere di delimitazione specificato e, facoltativamente, ad altre opzioni.Splits a string into a maximum number of substrings based on a specified delimiting character and, optionally, options. Divide una stringa in un numero massimo di sottostringhe in base al separatore di caratteri specificato, omettendo facoltativamente le sottostringhe vuote dal risultato.Splits a string into a maximum number of substrings based on the provided character separator, optionally omitting empty substrings from the result.

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

Carattere che delimita le sottostringhe in questa istanza.A character that delimits the substrings in this instance.

count
Int32

Numero massimo di elementi previsti nella matrice.The maximum number of elements expected in the array.

options
StringSplitOptions

Combinazione bit per bit dei valori di enumerazione, che specifica se tagliare le sottostringhe e includere le sottostringhe vuote.A bitwise combination of the enumeration values that specifies whether to trim substrings and include empty substrings.

Restituisce

String[]

Matrice che contiene al massimo count sottostringhe da questa istanza delimitate da separator.An array that contains at most count substrings from this instance that are delimited by separator.

Commenti

Se la stringa è già stata suddivisa count -1 volte, ma non è stata raggiunta la fine della stringa, l'ultima stringa della matrice restituita conterrà la sottostringa finale rimanente dell'istanza, non toccata.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Si applica a

Split(String[], Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base alle stringhe di delimitazione specificate e, facoltativamente, ad altre opzioni.Splits a string into a maximum number of substrings based on specified delimiting strings and, optionally, options.

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

Parametri

separator
String[]

Stringhe che delimitano le sottostringhe in questa stringa, matrice vuota senza delimitatori o null.The strings that delimit the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

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

options
StringSplitOptions

Combinazione bit per bit dei valori di enumerazione, che specifica se tagliare le sottostringhe e includere le sottostringhe vuote.A bitwise combination of the enumeration values that specifies whether to trim substrings and include empty substrings.

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.

Attributi

Eccezioni

count è negativo.count is negative.

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

Esempio

Nell'esempio seguente viene usata l' StringSplitOptions enumerazione per includere o escludere 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.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

// 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 \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

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

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

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

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

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{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]>

*/
    Dim s1 As String = ",ONE,,TWO,,,THREE,,"
    Dim s2 As String = "[stop]" &
                       "ONE[stop][stop]" &
                       "TWO[stop][stop][stop]" &
                       "THREE[stop][stop]"
    Dim charSeparators() As Char = {","c}
    Dim stringSeparators() As String = {"[stop]"}
    Dim result() As String
    ' ------------------------------------------------------------------------------
    ' Split a string delimited by characters.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    ' Display the original string and delimiter characters.
    Console.WriteLine("1a) The original string is ""{0}"".", s1)
    Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))

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

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

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

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

    ' ------------------------------------------------------------------------------
    ' Split a string delimited by another string.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)

    ' Display the original string and delimiter string.
    Console.WriteLine("2a) The original string is ""{0}"".", s2)
    Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))

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

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

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

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

End Sub


' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
    Console.WriteLine("The return value contains these {0} elements:", entries.Length)
    Dim entry As String
    For Each entry In entries
        Console.Write("<{0}>", entry)
    Next entry
    Console.Write(vbCrLf & vbCrLf)

End Sub

'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

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

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

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

Per passare null per il string[] separator parametro, è necessario indicare il tipo di null per distinguere la chiamata da altri overload, ad esempio Split(Char[], Int32, StringSplitOptions) .To pass null for the string[] separator parameter, you must indicate the type of the null to disambiguate the call from some other overloads, such as Split(Char[], Int32, StringSplitOptions). Nell'esempio seguente vengono illustrati diversi modi per identificare in modo univoco questo overload.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";

_ = phrase.Split(default(string[]), 3, StringSplitOptions.RemoveEmptyEntries);

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

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

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

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

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

Ogni elemento di separator definisce un delimitatore separato costituito da uno o più caratteri.Each element of separator defines a separate delimiter that consists of one or more characters. Se il options parametro è None e due delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente 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 in questa istanza, le prime count sottostringhe meno 1 vengono restituite nei primi count meno 1 elementi del valore restituito e i caratteri rimanenti in questa istanza vengono restituiti 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 disponibili e non viene generata alcuna eccezione.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Matrice di separatoreThe separator array

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

Dettagli confrontoComparison details

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

Il Split metodo cerca i delimitatori eseguendo confronti usando le regole di ordinamento ordinali con distinzione tra maiuscole e minuscole.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per ulteriori informazioni sugli ordinamenti di Word, stringa e ordinali, vedere l' 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 di separator il cui valore è null o la stringa vuota ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Per evitare risultati ambigui quando le stringhe in separator contengono caratteri in comune, il Split Metodo procede dall'inizio alla fine del valore dell'istanza e corrisponde al primo elemento in separator che è uguale a un delimitatore nell'istanza.To avoid ambiguous results when strings in separator have characters in common, the Split method proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. L'ordine in cui le sottostringhe vengono rilevate nell'istanza ha la precedenza sull'ordine degli 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 è "EF" e il secondo elemento è "bcde", il risultato dell'operazione Split sarà "a" e "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be "a" and "f". Ciò è dovuto al fatto che la sottostringa nell'istanza di, "bcde", viene rilevata e corrisponde a un elemento in separator prima che venga rilevata la sottostringa "f".This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

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

Considerazioni sulle prestazioniPerformance considerations

I Split Metodi allocano memoria per l'oggetto matrice restituito e 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 nell'applicazione, è consigliabile usare il IndexOf IndexOfAny metodo o 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 divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

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

Note per i chiamanti

In .NET Framework 3,5 e versioni precedenti, se al Split(Char[]) metodo viene passato un oggetto separator che è null o non contiene caratteri, il metodo usa un set leggermente diverso di spazi vuoti per suddividere la stringa rispetto al Trim(Char[]) metodo per tagliare la stringa.In .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 white-space characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Si applica a

Split(String[], StringSplitOptions)

Divide una stringa in sottostringhe in base a una stringa di delimitazione specificata e, facoltativamente, ad altre opzioni.Splits a string into substrings based on a specified delimiting string and, optionally, options.

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

Parametri

separator
String[]

Matrice di stringhe che delimitano le sottostringhe in questa stringa, matrice vuota senza delimitatori o null.An array of strings that delimit the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

Combinazione bit per bit dei valori di enumerazione, che specifica se tagliare le sottostringhe e includere le sottostringhe vuote.A bitwise combination of the enumeration values that specifies whether to trim substrings and include empty substrings.

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.

Attributi

Eccezioni

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

Esempio

Nell'esempio seguente viene illustrata la differenza nelle matrici restituite chiamando il metodo di una stringa String.Split(String[], StringSplitOptions) con il relativo options parametro uguale a 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.

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   \"{source}\".");
Console.WriteLine();
Console.WriteLine($"Using the delimiter string:\n   \"{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 ({result.Length} elements):");
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 ({result.Length} elements):");
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'
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()

' The example displays the following output:
'    Splitting the string:
'       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'    
'    Using the delimiter string:
'       "[stop]"
'    
'    Result including all elements (9 elements):
'       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
'    
'    Result including non-empty elements (3 elements):
'       'ONE' 'TWO' 'THREE'

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

string[] separators = { ",", ".", "!", "?", ";", ":", " " };
string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in words)
    Console.WriteLine(word);

// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate
    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

' 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 l' options argomento impostato su StringSplitOptions.RemoveEmptyEntries .Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. In questo modo si impedisce che la matrice restituita includa String.Empty valori che rappresentano corrispondenze di sottostringhe vuote tra i segni di punteggiatura e gli spazi vuoti.This prevents the returned array from including String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Commenti

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

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

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

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

Ogni elemento di separator definisce un delimitatore separato costituito da uno o più caratteri.Each element of separator defines a separate delimiter that consists of one or more characters. Se l' options argomento è None e due delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente 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. Se, ad esempio, sono separator inclusi due elementi, "-" e " _ ", il valore dell'istanza di stringa è "- _ AA- _ " e il valore dell' options argomento è None , il metodo restituisce una matrice di stringhe con i cinque elementi seguenti:For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a string array with the following five elements:

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

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

  3. "AA"."aa".

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

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

Matrice di separatoreThe separator array

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

Se il separator parametro è null o non contiene stringhe non vuote, verranno considerati come delimitatori gli spazi vuoti.If the separator parameter is null or contains no non-empty strings, white-space characters are assumed to be the delimiters. Gli spazi vuoti vengono definiti dallo standard Unicode e il Char.IsWhiteSpace metodo restituisce true se vengono passati al metodo.White-space characters are defined by the Unicode standard and the Char.IsWhiteSpace method returns true if they are passed to it.

Per passare null per il string[] separator parametro, è necessario indicare il tipo di null per distinguere la chiamata da altri overload, ad esempio Split(Char[], StringSplitOptions) .To pass null for the string[] separator parameter, you must indicate the type of the null to disambiguate the call from some other overloads, such as Split(Char[], StringSplitOptions). Nell'esempio seguente vengono illustrati diversi modi per identificare in modo univoco questo overload.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";

_ = phrase.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries);

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

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

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

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

Dettagli confrontoComparison details

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

Il Split metodo cerca i delimitatori eseguendo confronti usando le regole di ordinamento ordinali con distinzione tra maiuscole e minuscole.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Per ulteriori informazioni sugli ordinamenti di Word, stringa e ordinali, vedere l' 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 di separator il cui valore è null o la stringa vuota ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Per evitare risultati ambigui quando le stringhe in separator contengono caratteri in comune, l' Split operazione procede dall'inizio alla fine del valore dell'istanza e corrisponde al primo elemento in separator che è uguale a un delimitatore nell'istanza.To avoid ambiguous results when strings in separator have characters in common, the Split operation proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. L'ordine in cui le sottostringhe vengono rilevate nell'istanza ha la precedenza sull'ordine degli 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 è "EF" e il secondo elemento è "bcde", il risultato dell'operazione Split sarà una matrice di stringhe che contiene due elementi, "a" e "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be a string array that contains two elements, "a" and "f". Ciò è dovuto al fatto che la sottostringa nell'istanza di, "bcde", viene rilevata e corrisponde a un elemento in separator prima che venga rilevata la sottostringa "f".This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

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

Considerazioni sulle prestazioniPerformance considerations

I Split Metodi allocano memoria per l'oggetto matrice restituito e 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 nell'applicazione, è consigliabile usare il IndexOf IndexOfAny metodo o 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 divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

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

Note per i chiamanti

In .NET Framework 3,5 e versioni precedenti, se al Split(Char[]) metodo viene passato un oggetto separator che è null o non contiene caratteri, il metodo usa un set leggermente diverso di spazi vuoti per suddividere la stringa rispetto al Trim(Char[]) metodo per tagliare la stringa.In .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 white-space characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Si applica a

Split(String, Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base a una stringa di delimitazione specificata e, facoltativamente, ad altre opzioni.Splits a string into a maximum number of substrings based on a specified delimiting string and, optionally, options.

public string[] Split (string? separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
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

separator
String

Stringa che delimita le sottostringhe in questa istanza.A string that delimits the substrings in this instance.

count
Int32

Numero massimo di elementi previsti nella matrice.The maximum number of elements expected in the array.

options
StringSplitOptions

Combinazione bit per bit dei valori di enumerazione, che specifica se tagliare le sottostringhe e includere le sottostringhe vuote.A bitwise combination of the enumeration values that specifies whether to trim substrings and include empty substrings.

Restituisce

String[]

Matrice che contiene al massimo count sottostringhe da questa istanza delimitate da separator.An array that contains at most count substrings from this instance that are delimited by separator.

Commenti

Se la stringa è già stata suddivisa count -1 volte, ma non è stata raggiunta la fine della stringa, l'ultima stringa della matrice restituita conterrà la sottostringa finale rimanente dell'istanza, non toccata.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Si applica a

Split(Char[], StringSplitOptions)

Divide una stringa in sottostringhe in base ai caratteri di delimitazione specificati e ad altre opzioni.Splits a string into substrings based on specified delimiting characters and options.

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

Parametri

separator
Char[]

Matrice di caratteri che delimitano le sottostringhe in questa stringa, matrice vuota senza delimitatori o null.An array of characters that delimit the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

Combinazione bit per bit dei valori di enumerazione, che specifica se tagliare le sottostringhe e includere le sottostringhe vuote.A bitwise combination of the enumeration values that specifies whether to trim substrings and include empty substrings.

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.

Attributi

Eccezioni

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

Esempio

Nell'esempio seguente viene usata l' StringSplitOptions enumerazione per includere o escludere 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.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

// 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 \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

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

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

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

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

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{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]>

*/
    Dim s1 As String = ",ONE,,TWO,,,THREE,,"
    Dim s2 As String = "[stop]" &
                       "ONE[stop][stop]" &
                       "TWO[stop][stop][stop]" &
                       "THREE[stop][stop]"
    Dim charSeparators() As Char = {","c}
    Dim stringSeparators() As String = {"[stop]"}
    Dim result() As String
    ' ------------------------------------------------------------------------------
    ' Split a string delimited by characters.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    ' Display the original string and delimiter characters.
    Console.WriteLine("1a) The original string is ""{0}"".", s1)
    Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))

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

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

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

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

    ' ------------------------------------------------------------------------------
    ' Split a string delimited by another string.
    ' ------------------------------------------------------------------------------
    Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)

    ' Display the original string and delimiter string.
    Console.WriteLine("2a) The original string is ""{0}"".", s2)
    Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))

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

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

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

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

End Sub


' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
    Console.WriteLine("The return value contains these {0} elements:", entries.Length)
    Dim entry As String
    For Each entry In entries
        Console.Write("<{0}>", entry)
    Next entry
    Console.Write(vbCrLf & vbCrLf)

End Sub

'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a) The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Commenti

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

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

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

Ogni elemento di separator definisce un delimitatore separato costituito da un singolo carattere.Each element of separator defines a separate delimiter that consists of a single character. Se l' options argomento è None e due delimitatori sono adiacenti o viene trovato un delimitatore all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente 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. Se, ad esempio, separator include due elementi, '-' e '_' , il valore dell'istanza di stringa è "- _ AA- _ " e il valore dell' options argomento è None , il metodo restituisce una matrice di stringhe con i cinque elementi seguenti:For example, if separator includes two elements, '-' and '_', the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a string array with the following five elements:

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

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

  3. "AA"."aa".

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

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

Matrice di separatoreThe separator array

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

Per passare null per il char[] separator parametro, è necessario indicare il tipo di null per distinguere la chiamata da altri overload, ad esempio Split(String[], StringSplitOptions) .To pass null for the char[] separator parameter, you must indicate the type of the null to disambiguate the call from some other overloads, such as Split(String[], StringSplitOptions). Nell'esempio seguente vengono illustrati diversi modi per identificare in modo univoco questo overload.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";

_ = phrase.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries);

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

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

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

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

Dettagli confrontoComparison details

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

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

Considerazioni sulle prestazioniPerformance considerations

I Split Metodi allocano memoria per l'oggetto matrice restituito e 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 nell'applicazione, è consigliabile usare il IndexOf IndexOfAny metodo o 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 divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

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

Note per i chiamanti

In .NET Framework 3,5 e versioni precedenti, se al Split(Char[]) metodo viene passato un oggetto separator che è null o non contiene caratteri, il metodo usa un set leggermente diverso di spazi vuoti per suddividere la stringa rispetto al Trim(Char[]) metodo per tagliare la stringa.In .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 white-space characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Si applica a

Split(Char[], Int32)

Divide una stringa in un numero massimo di sottostringhe in base ai caratteri di delimitazione specificati.Splits a string into a maximum number of substrings based on specified delimiting characters.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count);
public string[] Split (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 delimitano le sottostringhe in questa stringa, matrice vuota senza delimitatori o null.An array of characters that delimit the substrings in this string, an empty array that contains no delimiters, or null.

count
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

count è negativo.count is negative.

Esempio

Nell'esempio seguente viene illustrato come count è possibile utilizzare per limitare il numero di stringhe restituite da Split .The following example demonstrates how count can be used to limit the number of strings returned by Split.

string name = "Alex Johnson III";

string[] subs = name.Split(null, 2);

string firstName = subs[0];
string lastName;
if (subs.Length > 1)
{
    lastName = subs[1];
}

// firstName = "Alex"
// lastName = "Johnson III"
Console.WriteLine("What is your name?")
Dim name As String = Console.ReadLine()

Dim substrings = name.Split(Nothing, 2)
Dim firstName As String = substrings(0)
Dim lastName As String

If substrings.Length > 1 Then
    lastName = substrings(1)
End If

' If the user enters "Alex Johnson III":
' firstName = "Alex"
' lastName = "Johnson III"

Commenti

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

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

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

Ogni elemento di separator definisce un carattere delimitatore separato.Each element of separator defines a separate delimiter character. Se due delimitatori sono adiacenti o un delimitatore viene individuato all'inizio o alla fine di questa istanza, l'elemento della matrice corrispondente 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 in questa istanza, le prime count - 1 sottostringhe vengono restituite nei primi count - 1 elementi del valore restituito e i caratteri rimanenti di questa istanza vengono restituiti nell'ultimo elemento del valore restituito.If there are more than count substrings in this instance, the first count - 1 substrings are returned in the first count - 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

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

La tabella seguente illustra alcuni esempi.The following table shows some examples.

LinguaggioLanguage Valore stringaString value SeparatoreSeparator Matrice restituitaReturned array
C#C# "42, 12, 19""42, 12, 19" New Char [] {',',''}new Char[] {',', ' '} {"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
Visual BasicVisual Basic "42, 12, 19""42, 12, 19" Char () = {"," c, "" c})Char() = {","c, " "c}) {"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
C#C# "42.. 12.. 19"."42..12..19." nuovo carattere [] {' .'}new Char[] {'.'} {"42", "", "12", "", "19", ""}{"42", "", "12", "", "19", ""}
Visual BasicVisual Basic "42.. 12.. 19"."42..12..19." Char () = {"." cChar() = {"."c} {"42", "", "12", "", "19", ""}{"42", "", "12", "", "19", ""}
C#C# Banana"Banana" nuovo carattere [] {' .'}new Char[] {'.'} {"Banana"}{"Banana"}
Visual BasicVisual Basic Banana"Banana" Char () = {"." cChar() = {"."c} {"Banana"}{"Banana"}
C#C# "Darb\nSmarba""Darb\nSmarba" nuovo carattere [] {}new Char[] {} {"Darb", "Smarba"}{"Darb", "Smarba"}
Visual BasicVisual Basic "Darb" & vbLf & "Smarba""Darb" & vbLf & "Smarba" Char () = {}Char() = {} {"Darb", "Smarba"}{"Darb", "Smarba"}
C#C# "Darb\nSmarba""Darb\nSmarba" Nullnull {"Darb", "Smarba"}{"Darb", "Smarba"}
Visual BasicVisual Basic "Darb" & vbLf & "Smarba""Darb" & vbLf & "Smarba" NothingNothing {"Darb", "Smarba"}{"Darb", "Smarba"}

Considerazioni sulle prestazioniPerformance considerations

I Split Metodi allocano 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 nell'applicazione, è consigliabile usare il IndexOf IndexOfAny metodo o 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 divide una stringa in corrispondenza di un carattere separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare un carattere separatore nella stringa.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Se si divide una stringa in corrispondenza di una stringa separatore, utilizzare IndexOf il IndexOfAny metodo o per individuare il primo carattere della stringa di separazione.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Usare quindi il Compare metodo per determinare se i caratteri successivi al primo carattere sono uguali ai caratteri rimanenti della stringa di separazione.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

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

Note per i chiamanti

In .NET Framework 3,5 e versioni precedenti, se al Split(Char[]) metodo viene passato un oggetto separator che è null o non contiene caratteri, il metodo usa un set leggermente diverso di spazi vuoti per suddividere la stringa rispetto al Trim(Char[]) metodo per tagliare la stringa.In .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 white-space characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Vedi anche

Si applica a

Split(Char, StringSplitOptions)

Divide una stringa in sottostringhe in base al carattere di delimitazione specificato e, facoltativamente, ad altre opzioni.Splits a string into substrings based on a specified delimiting character and, optionally, options.

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

Carattere che delimita le sottostringhe in questa stringa.A character that delimits the substrings in this string.

options
StringSplitOptions

Combinazione bit per bit dei valori di enumerazione, che specifica se tagliare le sottostringhe e includere le sottostringhe vuote.A bitwise combination of the enumeration values that specifies whether to trim substrings and include empty substrings.

Restituisce

String[]

Matrice i cui elementi contengono le sottostringhe da questa istanza delimitate da separator.An array whose elements contain the substrings from this instance that are delimited by separator.

Si applica a

Split(String, StringSplitOptions)

Suddivide una stringa in sottostringhe in base al separatore di stringa specificato.Splits a string into substrings that are based on the provided string separator.

public string[] Split (string? separator, StringSplitOptions options = System.StringSplitOptions.None);
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

separator
String

Stringa che delimita le sottostringhe in questa stringa.A string that delimits the substrings in this string.

options
StringSplitOptions

Combinazione bit per bit dei valori di enumerazione, che specifica se tagliare le sottostringhe e includere le sottostringhe vuote.A bitwise combination of the enumeration values that specifies whether to trim substrings and include empty substrings.

Restituisce

String[]

Matrice i cui elementi contengono le sottostringhe da questa istanza delimitate da separator.An array whose elements contain the substrings from this instance that are delimited by separator.

Si applica a

Split(Char[])

Divide una stringa in sottostringhe in base ai caratteri di delimitazione specificati.Splits a string into substrings based on specified delimiting characters.

public:
 cli::array <System::String ^> ^ Split(... cli::array <char> ^ separator);
public string[] Split (params 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 di delimitazione, matrice vuota che non contiene delimitatori o null.An array of delimiting characters, 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.

Esempio

Nell'esempio seguente viene illustrato come estrarre singole parole da un blocco di testo trattando il carattere di spazio ( ) e il carattere di tabulazione ( \t ) come delimitatori.The following example demonstrates how to extract individual words from a block of text by treating the space character ( ) and tab character (\t) as delimiters. La stringa divisa include entrambi questi caratteri.The string being split includes both of these characters.

string s = "Today\tI'm going to school";
string[] subs = s.Split(' ', '\t');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: Today
// Substring: I'm
// Substring: going
// Substring: to
// Substring: school
Dim s As String = "Today" & vbTab & "I'm going to school"
Dim subs As String() = s.Split(" "c, Char.Parse(vbTab))

For Each substring In subs
    Console.WriteLine("Substring: " & substring)
Next

' This example produces the following output:
'
' Substring: Today
' Substring: I 'm
' Substring: going
' Substring: to
' Substring: school

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.

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

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

Ogni elemento di separator definisce un carattere delimitatore separato.Each element of separator defines a separate delimiter character. Se due delimitatori sono adiacenti o un delimitatore viene individuato all'inizio o alla fine di questa istanza, l'elemento corrispondente nella matrice restituita 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.

La tabella seguente illustra alcuni esempi.The following table shows some examples.

LinguaggioLanguage Valore stringaString value SeparatoreSeparator Matrice restituitaReturned array
C#C# "42, 12, 19""42, 12, 19" New Char [] {',',''}new Char[] {',', ' '} {"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
Visual BasicVisual Basic "42, 12, 19""42, 12, 19" Char () = {"," c, "" c})Char() = {","c, " "c}) {"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
C#C# "42.. 12.. 19"."42..12..19." nuovo carattere [] {' .'}new Char[] {'.'} {"42", "", "12", "", "19", ""}{"42", "", "12", "", "19", ""}
Visual BasicVisual Basic "42.. 12.. 19"."42..12..19." Char () = {"." cChar() = {"."c} {"42", "", "12", "", "19", ""}{"42", "", "12", "", "19", ""}
C#C# Banana"Banana" nuovo carattere [] {' .'}new Char[] {'.'} {"Banana"}{"Banana"}
Visual BasicVisual Basic Banana"Banana" Char () = {"." cChar() = {"."c} {"Banana"}{"Banana"}
C#C# "Darb\nSmarba""Darb\nSmarba" nuovo carattere [] {}new Char[] {} {"Darb", "Smarba"}{"Darb", "Smarba"}
Visual BasicVisual Basic "Darb" & vbLf & "Smarba""Darb" & vbLf & "Smarba" Char () = {}Char() = {} {"Darb", "Smarba"}{"Darb", "Smarba"}
C#C# "Darb\nSmarba""Darb\nSmarba" Nullnull {"Darb", "Smarba"}{"Darb", "Smarba"}
Visual BasicVisual Basic "Darb" & vbLf & "Smarba""Darb" & vbLf & "Smarba" NothingNothing {"Darb", "Smarba"}{"Darb", "Smarba"}

Matrice di separatoreThe separator array

Ogni elemento del separatore definisce un delimitatore separato costituito da un singolo carattere.Each element of separator defines a separate delimiter that consists of a single character.

Se l' separator argomento è null o non contiene caratteri, il metodo considera gli spazi vuoti come delimitatori.If the separator argument is null or contains no characters, the method treats white-space characters as the delimiters. Gli spazi vuoti vengono definiti dallo standard Unicode e il Char.IsWhiteSpace metodo restituisce true se viene passato un carattere di spazio vuoto.White-space characters are defined by the Unicode standard, and the Char.IsWhiteSpace method returns true if a white-space character is passed to it.

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

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

string value = "This is a short string.";
char delimiter = 's';
string[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
    Console.WriteLine(substring);

// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.
    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

' The example displays the following output:
'
'     Thi
'      i
'      a
'     hort
'     tring.

Poiché il separator parametro è decorato con l' ParamArrayAttribute attributo, i compilatori interpretano un singolo carattere come matrice di caratteri a elemento singolo.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. Questo non avviene per altri String.Split Overload che includono un separator parametro. è necessario passare in modo esplicito questi overload a una matrice di caratteri come 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 confrontoComparison details

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

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

Considerazioni sulle prestazioniPerformance considerations

I Split Metodi allocano memoria per l'oggetto matrice restituito e 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 nell'applicazione, è consigliabile usare il IndexOf IndexOfAny metodo o.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. È anche possibile usare il Compare metodo per individuare una sottostringa all'interno di una stringa.You also have the option of using the Compare method to locate a substring within a string.

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

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

Note per i chiamanti

In .NET Framework 3,5 e versioni precedenti, se al Split(Char[]) metodo viene passato un oggetto separator che è null o non contiene caratteri, il metodo usa un set leggermente diverso di spazi vuoti per suddividere la stringa rispetto al Trim(Char[]) metodo per tagliare la stringa.In .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 white-space characters to split the string than the Trim(Char[]) method does to trim the string. A partire da .NET Framework 4, entrambi i metodi usano un set identico di caratteri di spazio vuoto Unicode.Starting with .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Vedi anche

Si applica a