String.Split Methode

Definition

Gibt ein Zeichenfolgenarray zurück, das die Teilzeichenfolgen dieser Instanz enthält, die durch Elemente eines angegebenen Zeichenfolgen- oder Unicode-Zeichenarrays getrennt sind.

Überlädt

Split(Char, Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand eines angegebenen Trennzeichens und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt. Hier wird eine Zeichenfolge in eine maximale Anzahl von Teilzeichenfolgen anhand des angegebenen Ersatztrennzeichens unterteilt, wobei optional leere Teilzeichenfolgen aus dem Ergebnis ausgelassen werden.

Split(String[], Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand von angegebenen Trennzeichenfolgen und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

Split(Char[], Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand von angegebenen Trennzeichen und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

Split(String[], StringSplitOptions)

Hier wird eine Zeichenfolge anhand einer angegebenen Trennzeichenfolge und optional von Optionen in Teilzeichenfolgen unterteilt.

Split(String, Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand einer angegebenen Trennzeichenfolge und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

Split(Char[], StringSplitOptions)

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen und der Optionen in Teilzeichenfolgen unterteilt.

Split(Char[], Int32)

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen in eine maximale Anzahl von Teilzeichenfolgen unterteilt.

Split(Char, StringSplitOptions)

Hier wird eine Zeichenfolge anhand eines angegebenen Trennzeichens und optional von Optionen in Teilzeichenfolgen unterteilt.

Split(String, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in Teilzeichenfolgen.

Split(Char[])

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen in Teilzeichenfolgen unterteilt.

Hinweise

Split wird verwendet, um eine trennzeichende Zeichenfolge in Unterzeichenfolgen zu unterbrechen. Sie können entweder ein Zeichenarray oder ein Zeichenfolgenarray verwenden, um null oder mehr Trennzeichen oder Zeichenfolgen anzugeben. Wenn keine Trennzeichen angegeben werden, wird die Zeichenfolge auf Leerzeichen aufgeteilt.

Überladungen der Split Methode ermöglichen es Ihnen, die Anzahl der von der Methode zurückgegebenen Teilzeichenfolgen zu beschränken, um anzugeben, ob leere Zeichenfolgen und/oder Teilzeichenfolgen im Ergebnis (Split(Char[], Int32)die und Methoden) enthalten oder beide (die Split(Char[], Int32, StringSplitOptions) Split(Char[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], Int32, StringSplitOptions) und Methoden) enthalten sollen.

Tipp

Die Split Methode ist nicht immer die beste Möglichkeit, eine trennzeichende Zeichenfolge in Unterzeichenfolgen zu unterbrechen. Wenn Sie nicht alle Teilzeichenfolgen einer getrennten Zeichenfolge extrahieren möchten, oder wenn Sie eine Zeichenfolge basierend auf einem Muster anstelle eines Satz von Trennzeichen analysieren möchten, sollten Sie reguläre Ausdrücke verwenden oder eine der Suchmethoden kombinieren, die den Index eines Zeichens mit der Substring Methode zurückgeben. Weitere Informationen finden Sie unter Extrahieren von Unterzeichenfolgen aus einer Zeichenfolge.

Beispiel

Die folgenden Beispiele zeigen drei verschiedene Überladungen von String.Split(). Im ersten Beispiel wird die Split(Char[]) Überladung aufgerufen und in einem einzelnen Trennzeichen übergeben.

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.
let s = "You win some. You lose some."

let subs = s.Split ' '

for sub in subs do
    printfn $"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.

Wie Sie sehen können, sind die Punktzeichen (.) in zwei der Teilzeichenfolgen enthalten. Wenn Sie die Punktzeichen ausschließen möchten, können Sie das Punktzeichen als zusätzliches Trennzeichen hinzufügen. Im nächsten Beispiel wird gezeigt, wie dies geschieht.

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:
let s = "You win some. You lose some."

let subs = s.Split(' ', '.')

for sub in subs do
    printfn $"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:

Die Punkte sind aus den Teilzeichenfolgen verschwunden, aber jetzt wurden zwei zusätzliche leere Teilzeichenfolgen eingefügt. Diese leere Teilzeichenfolge stellt die Unterzeichenfolge zwischen einem Wort und dem zeitraum dar, der es folgt. Um leere Teilzeichenfolgen aus dem resultierenden Array auszuschließen, können Sie die Überladung Split(Char[], StringSplitOptions) aufrufen und StringSplitOptions.RemoveEmptyEntries für den Parameter options angeben.

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
let s = "You win some. You lose some."
let separators = [| ' '; '.' |]

let subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries)

for sub in subs do
    printfn $"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

Die Abschnitte für die einzelnen Überladungen String.Split() enthalten weitere Beispiele.

Split(Char, Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand eines angegebenen Trennzeichens und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt. Hier wird eine Zeichenfolge in eine maximale Anzahl von Teilzeichenfolgen anhand des angegebenen Ersatztrennzeichens unterteilt, wobei optional leere Teilzeichenfolgen aus dem Ergebnis ausgelassen werden.

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()

Parameter

separator
Char

Ein Zeichen, das die Teilzeichenfolgen in dieser Instanz trennt.

count
Int32

Die maximale Anzahl der im Array erwarteten Elemente.

options
StringSplitOptions

Dies ist eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen zugeschnitten und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, das maximal count Teilzeichenfolgen von dieser Instanz enthält, die durch separator getrennt sind.

Hinweise

Wenn die Zeichenfolge bereits geteilt wurde count - 1 mal, aber das Ende der Zeichenfolge nicht erreicht wurde, enthält die letzte Zeichenfolge im zurückgegebenen Array die verbleibende nachgestellte Teilzeichenfolge dieser Instanz, unberührt.

Gilt für:

Split(String[], Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand von angegebenen Trennzeichenfolgen und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

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()

Parameter

separator
String[]

Hierbei handelt es sich um die Zeichenfolgen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array ohne Trennzeichen, oder null.

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

options
StringSplitOptions

Dies ist eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen zugeschnitten und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen in dieser Zeichenfolge enthält, die durch ein oder mehr Zeichenfolgen aus separator getrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Attribute

Ausnahmen

count ist ein negativer Wert.

options entspricht keinem der StringSplitOptions-Werte.

Beispiele

Im folgenden Beispiel wird die StringSplitOptions Aufzählung verwendet, um Teilzeichenfolgen einzuschließen oder auszuschließen, die von der Split Methode generiert werden.

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

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
 
// Display the array of separated strings using a local function
let show  (entries: string[]) =
    printfn $"The return value contains these {entries.Length} elements:"
    for entry in entries do
        printf $"<{entry}>"
    printf "\n\n"

let s1 = ",ONE,,TWO,,,THREE,,"
let s2 = "[stop]" +
         "ONE[stop][stop]" +
         "TWO[stop][stop][stop]" +
         "THREE[stop][stop]"
let charSeparators = [| ',' |]
let stringSeparators = [| "[stop]" |]
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
printfn "1) Split a string delimited by characters:\n"

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

// Split a string delimited by characters and return all elements.
printfn "1b) Split a string delimited by characters and return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let 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.
printfn "1d) Split a string delimited by characters and return 2 elements:"
let 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.
printfn "1e) Split a string delimited by characters and return 2 non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
printfn "2) Split a string delimited by another string:\n"

// Display the original string and delimiter string.
printfn $"2a) The original string is \"{s2}\"."
printfn $"The delimiter string is \"{stringSeparators[0]}\".\n"

// Split a string delimited by another string and return all elements.
printfn "2b) Split a string delimited by another string and return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result

// Split the original string at the delimiter and return all non-empty elements.
printfn "2c) Split a string delimited by another string and return all non-empty elements:"
let 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.
printfn "2d) Split a string delimited by another string and return 2 elements:"
let 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.
printfn "2e) Split a string delimited by another string and return 2 non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

(*
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]>
'

Hinweise

Trennzeichenzeichenfolgen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.

Wenn diese Instanz keine der Zeichenfolgen separatorenthält oder der count Parameter 1 ist, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

Wenn der separator Parameter keine Zeichen enthält null , werden Leerzeichen als Trennzeichen angenommen. Leerzeichen werden durch den Unicode-Standard definiert, und die Char.IsWhiteSpace Methode gibt zurück true , wenn sie an ihn übergeben werden.

Um den string[] separator Parameter zu übergebennull, müssen Sie den Typ des null Aufrufs von anderen Überladungen, zSplit(Char[], Int32, StringSplitOptions). B. , angeben. Das folgende Beispiel zeigt mehrere Möglichkeiten, um diese Überladung eindeutig zu identifizieren.

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);
let phrase = "The quick  brown fox"

phrase.Split(Unchecked.defaultof<string[]>, 3, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split(null :> string[], 3, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split((null: string[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
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)

Wenn der count Parameter null ist oder der options Parameter RemoveEmptyEntries und die Länge dieser Instanz null ist, wird ein leeres Array zurückgegeben.

Jedes Element definiert separator ein separates Trennzeichen, das aus einem oder mehreren Zeichen besteht. Wenn der options Parameter ist None, und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält Emptydas entsprechende Arrayelement .

Wenn in dieser Instanz mehr als count Teilzeichenfolgen vorhanden sind, werden die ersten count minus 1 Teilzeichenfolgen in den ersten count minus 1 Elementen des Rückgabewerts zurückgegeben, und die verbleibenden Zeichen in dieser Instanz werden im letzten Element des Rückgabewerts zurückgegeben.

Wenn count die Anzahl der Teilzeichenfolgen größer ist, werden die verfügbaren Teilzeichenfolgen zurückgegeben, und es wird keine Ausnahme ausgelöst.

Das Trennarray

Wenn eines der Elemente separator aus mehreren Zeichen besteht, wird die gesamte Teilzeichenfolge als Trennzeichen betrachtet. Wenn beispielsweise eines der Elemente in separator "10" lautet, versuchen Sie, die Zeichenfolge "This10is10a10string" aufzuteilen. gibt dieses vierstufige Array zurück: { "This", "is", "a", "string". }.

Vergleichsdetails

Die Split Methode extrahiert die Teilzeichenfolgen in dieser Zeichenfolge, die durch eine oder mehrere der Zeichenfolgen im separator Parameter getrennt sind, und gibt diese Teilzeichenfolgen als Elemente eines Arrays zurück.

Die Split Methode sucht nach Trennzeichen, indem Vergleiche mithilfe von Ordnungsregeln mit Groß-/Kleinschreibung durchgeführt werden. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierungen finden Sie in der System.Globalization.CompareOptions Enumeration.

Die Split Methode ignoriert jedes Element dessen separator Wert null oder die leere Zeichenfolge ("").

Um mehrdeutige Ergebnisse zu vermeiden, wenn Zeichenfolgen separator zeichen gemeinsam enthalten, wird die Split Methode vom Anfang bis zum Ende des Werts der Instanz fortgesetzt und stimmt mit dem ersten Element separator überein, das einem Trennzeichen in der Instanz entspricht. Die Reihenfolge, in der Teilzeichenfolgen in der Instanz gefunden werden, hat Vorrang vor der Reihenfolge der Elemente in separator.

Ziehen Sie beispielsweise eine Instanz in Betracht, deren Wert "abcdef" ist. Wenn das erste Element in separator "ef" war und das zweite Element "bcde" lautete, lautete das Ergebnis des Geteilten Vorgangs "a" und "f". Dies liegt daran, dass die Teilzeichenfolge in der Instanz "bcde" aufgetreten ist und einem Element entspricht separator , bevor die Teilzeichenfolge "f" gefunden wird.

Wenn jedoch das erste Element separator von "bcd" und das zweite Element "bc" lautete, lautete das Ergebnis des geteilten Vorgangs "a" und "ef". Dies liegt daran, dass "bcd" das erste Trennzeichen ist, das separator einem Trennzeichen in der Instanz entspricht. Wenn die Reihenfolge der Trennzeichen umgekehrt wurde, sodass das erste Element "bc" war und das zweite Element "bcd" lautete, lautete das Ergebnis "a" und "def".

Überlegungen zur Leistung

Die Split Methoden weisen Arbeitsspeicher für das zurückgegebene Arrayobjekt und ein String Objekt für jedes Arrayelement zu. Wenn Ihre Anwendung eine optimale Leistung erfordert oder wenn die Verwaltung der Speicherzuweisung in Ihrer Anwendung von entscheidender Bedeutung ist, sollten Sie die Verwendung der IndexOf IndexOfAny Methode und optional die Compare Methode verwenden, um eine Teilzeichenfolge innerhalb einer Zeichenfolge zu suchen.

Wenn Sie eine Zeichenfolge bei einem Trennzeichen teilen, verwenden Sie die IndexOf Oder-Methode IndexOfAny , um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge in einer Trennzeichenfolge teilen, verwenden Sie die IndexOf oder IndexOfAny methode, um das erste Zeichen der Trennzeichenfolge zu suchen. Verwenden Sie dann die Compare Methode, um zu bestimmen, ob die Zeichen nach diesem ersten Zeichen den verbleibenden Zeichen der Trennzeichenfolge entsprechen.

Wenn derselbe Zeichensatz zum Teilen von Zeichenfolgen in mehreren Split Methodenaufrufen verwendet wird, sollten Sie außerdem ein einzelnes Array erstellen und in jedem Methodenaufruf darauf verweisen. Dadurch wird der zusätzliche Aufwand jedes Methodenaufrufs erheblich reduziert.

Hinweise für Aufrufer

Wenn die Split(Char[]) Methode in .NET Framework 3.5 und früheren Versionen ein separator Objekt übergeben wird, das null keine Zeichen enthält, verwendet die Methode eine geringfügig andere Reihe von Leerzeichen, um die Zeichenfolge zu teilen als die Trim(Char[]) Methode, um die Zeichenfolge zu kürzen. Ab .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.

Gilt für:

Split(Char[], Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand von angegebenen Trennzeichen und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

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()

Parameter

separator
Char[]

Hierbei handelt es sich um ein Array von Zeichen, die die Teilzeichenfolgen dieser Zeichenfolge trennen, ein leeres Array ohne Trennzeichen oder null.

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

options
StringSplitOptions

Dies ist eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen zugeschnitten und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, das die Teilzeichenfolgen in dieser Zeichenfolge enthält, die durch ein oder mehr Zeichen aus separator getrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Attribute

Ausnahmen

count ist ein negativer Wert.

options entspricht keinem der StringSplitOptions-Werte.

Beispiele

Im folgenden Beispiel wird die StringSplitOptions Aufzählung verwendet, um Teilzeichenfolgen einzuschließen oder auszuschließen, die von der Split Methode generiert werden.

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

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
 
// Display the array of separated strings using a local function
let show  (entries: string[]) =
    printfn $"The return value contains these {entries.Length} elements:"
    for entry in entries do
        printf $"<{entry}>"
    printf "\n\n"

let s1 = ",ONE,,TWO,,,THREE,,"
let s2 = "[stop]" +
         "ONE[stop][stop]" +
         "TWO[stop][stop][stop]" +
         "THREE[stop][stop]"
let charSeparators = [| ',' |]
let stringSeparators = [| "[stop]" |]
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
printfn "1) Split a string delimited by characters:\n"

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

// Split a string delimited by characters and return all elements.
printfn "1b) Split a string delimited by characters and return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let 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.
printfn "1d) Split a string delimited by characters and return 2 elements:"
let 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.
printfn "1e) Split a string delimited by characters and return 2 non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
printfn "2) Split a string delimited by another string:\n"

// Display the original string and delimiter string.
printfn $"2a) The original string is \"{s2}\"."
printfn $"The delimiter string is \"{stringSeparators[0]}\".\n"

// Split a string delimited by another string and return all elements.
printfn "2b) Split a string delimited by another string and return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result

// Split the original string at the delimiter and return all non-empty elements.
printfn "2c) Split a string delimited by another string and return all non-empty elements:"
let 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.
printfn "2d) Split a string delimited by another string and return 2 elements:"
let 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.
printfn "2e) Split a string delimited by another string and return 2 non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

(*
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]>
'

Hinweise

Trennzeichen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.

Wenn diese Instanz keines der Zeichen enthält separatoroder der count Parameter 1 ist, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

Wenn der separator Parameter keine Zeichen enthält null , werden Leerzeichen als Trennzeichen angenommen. Leerzeichen werden durch den Unicode-Standard definiert, und die Char.IsWhiteSpace Methode gibt zurück true , wenn sie an ihn übergeben werden.

Um den char[] separator Parameter zu übergebennull, müssen Sie den Typ des null Aufrufs von anderen Überladungen, zSplit(String[], Int32, StringSplitOptions). B. , angeben. Das folgende Beispiel zeigt mehrere Möglichkeiten, um diese Überladung eindeutig zu identifizieren.

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);
let phrase = "The quick  brown fox"

phrase.Split(Unchecked.defaultof<char[]>, 3, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split(null :> char[], 3, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split((null: char[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
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)

Wenn der count Parameter null ist oder der options Parameter RemoveEmptyEntries und die Länge dieser Instanz null ist, wird ein leeres Array zurückgegeben.

Jedes Element definiert separator ein separates Trennzeichen. Wenn der options Parameter ist None, und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält Emptydas entsprechende Arrayelement .

Wenn in dieser Instanz mehr als count Teilzeichenfolgen vorhanden sind, werden die ersten count minus 1 Teilzeichenfolgen in den ersten count minus 1 Elementen des Rückgabewerts zurückgegeben, und die verbleibenden Zeichen in dieser Instanz werden im letzten Element des Rückgabewerts zurückgegeben.

Wenn count die Anzahl der Teilzeichenfolgen größer ist, werden die verfügbaren Teilzeichenfolgen zurückgegeben, und es wird keine Ausnahme ausgelöst.

Überlegungen zur Leistung

Die Split Methoden weisen Arbeitsspeicher für das zurückgegebene Arrayobjekt und ein String Objekt für jedes Arrayelement zu. Wenn Ihre Anwendung eine optimale Leistung erfordert oder wenn die Verwaltung der Speicherzuweisung in Ihrer Anwendung von entscheidender Bedeutung ist, sollten Sie die Verwendung der IndexOf IndexOfAny Methode und optional die Compare Methode verwenden, um eine Teilzeichenfolge innerhalb einer Zeichenfolge zu suchen.

Wenn Sie eine Zeichenfolge bei einem Trennzeichen teilen, verwenden Sie die IndexOf Oder-Methode IndexOfAny , um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge in einer Trennzeichenfolge teilen, verwenden Sie die IndexOf oder IndexOfAny methode, um das erste Zeichen der Trennzeichenfolge zu suchen. Verwenden Sie dann die Compare Methode, um zu bestimmen, ob die Zeichen nach diesem ersten Zeichen den verbleibenden Zeichen der Trennzeichenfolge entsprechen.

Wenn derselbe Zeichensatz zum Teilen von Zeichenfolgen in mehreren Split Methodenaufrufen verwendet wird, sollten Sie außerdem ein einzelnes Array erstellen und in jedem Methodenaufruf darauf verweisen. Dadurch wird der zusätzliche Aufwand jedes Methodenaufrufs erheblich reduziert.

Hinweise für Aufrufer

Wenn die Split(Char[]) Methode in .NET Framework 3.5 und früheren Versionen ein separator Objekt übergeben wird, das null keine Zeichen enthält, verwendet die Methode eine geringfügig andere Reihe von Leerzeichen, um die Zeichenfolge zu teilen als die Trim(Char[]) Methode, um die Zeichenfolge zu kürzen. Ab .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.

Gilt für:

Split(String[], StringSplitOptions)

Hier wird eine Zeichenfolge anhand einer angegebenen Trennzeichenfolge und optional von Optionen in Teilzeichenfolgen unterteilt.

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()

Parameter

separator
String[]

Hierbei handelt es sich um ein Array von Zeichenfolgen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array ohne Trennzeichen, oder null.

options
StringSplitOptions

Dies ist eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen zugeschnitten und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen in dieser Zeichenfolge enthält, die durch ein oder mehr Zeichenfolgen aus separator getrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Attribute

Ausnahmen

options entspricht keinem der StringSplitOptions-Werte.

Beispiele

Im folgenden Beispiel wird der Unterschied in den Arrays veranschaulicht, die durch Aufrufen der Methode einer Zeichenfolge String.Split(String[], StringSplitOptions) mit seinem options Parameter gleich StringSplitOptions.None und 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'
let source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
let stringSeparators = [| "[stop]" |]

// Display the original string and delimiter string.
printfn $"Splitting the string:\n   \"{source}\".\n"
printfn $"Using the delimiter string:\n   \"{stringSeparators[0]}\"\n"

// Split a string delimited by another string and return all elements.
let result = source.Split(stringSeparators, StringSplitOptions.None)
printfn $"Result including all elements ({result.Length} elements):"
printf "   "
for s in result do
    printf $"""'{if String.IsNullOrEmpty s then "<>" else s}' """
printfn "\n"

// Split delimited by another string and return all non-empty elements.
let result = source.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
Console.WriteLine($"Result including non-empty elements ({result.Length} elements):")
printf "   "
for s in result do
    printf $"""'{if String.IsNullOrEmpty s then "<>" else s}' """
printfn ""

// 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]"
//    
//    let result including all elements (9 elements):
//       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//    
//    let 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'

Im folgenden Beispiel wird ein Array von Trennzeichen definiert, die Interpunktion und Leerzeichen enthalten. Durch das Übergeben dieses Arrays zusammen mit einem Wert StringSplitOptions.RemoveEmptyEntries an die Methode wird ein Array zurückgegeben, das aus den einzelnen Wörtern aus der Split(String[], StringSplitOptions) Zeichenfolge besteht.

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
let separators = [| ","; "."; "!"; "?"; ""; ":"; " " |]
let value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
let words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
for word in words do
    printfn $"${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

Beachten Sie, dass die Methode mit dem options Argument auf " aufgerufen StringSplitOptions.RemoveEmptyEntrieswird. Dadurch wird verhindert, dass das zurückgegebene Array Werte enthält String.Empty , die leere Teilzeichenfolgen zwischen Punktpunktzeichen und Leerzeichen darstellen.

Hinweise

Wenn eine Zeichenfolge durch einen bekannten Satz von Zeichenfolgen getrennt wird, können Sie die Split Methode verwenden, um sie in Unterzeichenfolgen zu trennen.

Trennzeichenzeichenfolgen sind nicht in die Elemente des zurückgegebenen Arrays enthalten. Wenn das separator Array z. B. die Zeichenfolge "-" enthält und der Wert der aktuellen Zeichenfolgeninstanz "aa--bb-cc" lautet, gibt die Methode ein Array zurück, das drei Elemente enthält: "aa", "bb" und "cc".

Wenn diese Instanz keine der Zeichenfolgen enthält separator, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

Wenn der Parameter und die Länge dieser Instanz null istRemoveEmptyEntries, gibt die options Methode ein leeres Array zurück.

Jedes Element definiert separator ein separates Trennzeichen, das aus einem oder mehreren Zeichen besteht. Wenn das Argument Noneist, und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält String.Emptydas options entsprechende Arrayelement . Wenn separator beispielsweise zwei Elemente, "-" und "_", der Wert der Zeichenfolgeninstanz "-_aa"_, und der Wert des options Arguments Noneist, gibt die Methode ein Zeichenfolgenarray mit den folgenden fünf Elementen zurück:

  1. String.Empty, die die leere Zeichenfolge darstellt, die der Unterzeichenfolge "-" bei Index 0 vorangestellt ist.

  2. String.Empty, die die leere Zeichenfolge zwischen der Unterzeichenfolge "-" bei Index 0 und der Unterzeichenfolge "_" bei Index 1 darstellt.

  3. "aa".

  4. String.Empty, die die leere Zeichenfolge darstellt, die der Unterzeichenfolge "-" bei Index 4 folgt.

  5. String.Empty, die die leere Zeichenfolge darstellt, die der Unterzeichenfolge "_" bei Index 5 folgt.

Das Trennzeichenarray

Wenn eine der Elemente separator aus mehreren Zeichen besteht, wird die gesamte Teilzeichenfolge als Trennzeichen angesehen. Wenn beispielsweise eine der Elemente in separator "10" lautet, versuchen Sie, die Zeichenfolge "This10is10a10string" zu teilen. gibt das folgende Vierelementarray zurück: { "This", "is", "a", "string". }.

Wenn der separator Parameter keine leeren Zeichenfolgen enthält null , werden Leerzeichen als Trennzeichen angenommen. Leerzeichen werden durch den Unicode-Standard definiert, und die Char.IsWhiteSpace Methode gibt true zurück, wenn sie an sie übergeben werden.

Um den Parameter zu übergeben null , müssen Sie den Typ des string[] separator null Aufrufs von einigen anderen Überladungen angeben, z Split(Char[], StringSplitOptions). B. . Im folgenden Beispiel werden verschiedene Möglichkeiten gezeigt, diese Überladung eindeutig zu identifizieren.

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);
let phrase = "The quick  brown fox"

phrase.Split(Unchecked.defaultof<string[]>, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split(null :> string[], StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split((null: string[]), StringSplitOptions.RemoveEmptyEntries) |> ignore
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)

Vergleichsdetails

Die Split Methode extrahiert die Unterzeichenfolgen in dieser Zeichenfolge, die durch eine oder mehrere der Zeichenfolgen im separator Parameter getrennt sind, und gibt diese Unterzeichenfolgen als Elemente eines Arrays zurück.

Die Split Methode sucht nach Trennzeichen, indem Vergleiche mithilfe von Groß-/Kleinschreibungs-Sortierregeln ausgeführt werden. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordinalsortierungen finden Sie in der System.Globalization.CompareOptions Aufzählung.

Die Split Methode ignoriert jedes Element dessen separator Wert null oder die leere Zeichenfolge ("").

Um mehrdeutige Ergebnisse zu vermeiden, wenn Zeichenfolgen in gemeinsamen Zeichen enthalten, führt der Split Vorgang vom Anfang bis zum Ende des Werts separator der Instanz aus, und entspricht dem ersten Element, das einem Trennzeichen separator in der Instanz entspricht. Die Reihenfolge, in der Teilzeichenfolgen in der Instanz auftreten, hat Vorrang vor der Reihenfolge der Elemente in separator.

Betrachten Sie beispielsweise eine Instanz, deren Wert "abcdef" ist. Wenn das erste Element "ef" war und das zweite Element separator "bcde" war, wäre das Ergebnis des geteilten Vorgangs ein Zeichenfolgenarray, das zwei Elemente enthält, "a" und "f". Dies liegt daran, dass die Unterzeichenfolge in der Instanz "bcde" aufgetreten ist und einem Element separator entspricht, bevor die Unterzeichenfolge "f" aufgetreten ist.

Wenn jedoch das erste Element "bcd" und das zweite Element separator "bc" war, wäre das Ergebnis des geteilten Vorgangs ein Zeichenfolgenarray, das zwei Elemente enthält, "a" und "ef". Dies liegt daran, dass "bcd" das erste separator Trennzeichen ist, das einem Trennzeichen in der Instanz entspricht. Wenn die Reihenfolge der Trennzeichen umgekehrt wurde, sodass das erste Element "bc" war und das zweite Element "bcd" war, wäre das Ergebnis ein Zeichenfolgenarray, das zwei Elemente enthält, "a" und "def".

Überlegungen zur Leistung

Die Split Methoden weisen Speicher für das zurückgegebene Arrayobjekt und ein String Objekt für jedes Arrayelement zu. Wenn Ihre Anwendung optimale Leistung erfordert oder wenn die Verwaltung der Speicherzuweisung in Ihrer Anwendung wichtig ist, sollten Sie die Verwendung IndexOf der IndexOfAny Methode und optional die Compare Methode verwenden, um eine Teilzeichenfolge in einer Zeichenfolge zu suchen.

Wenn Sie eine Zeichenfolge in einem Trennzeichen teilen, verwenden Sie die IndexOf IndexOfAny Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge bei einer Trennzeichenzeichenfolge teilen, verwenden Sie die IndexOf IndexOfAny methode, um das erste Zeichen der Trennzeichenzeichenfolge zu suchen. Verwenden Sie dann die Compare Methode, um zu bestimmen, ob die Zeichen nach diesem ersten Zeichen den verbleibenden Zeichen der Trennzeichenzeichenfolge entsprechen.

Wenn außerdem dieselbe Zeichenmenge zum Teilen von Zeichenfolgen in mehreren Split Methodenaufrufen verwendet wird, sollten Sie ein einzelnes Array erstellen und in jedem Methodenaufruf darauf verweisen. Dadurch wird der zusätzliche Aufwand jedes Methodenaufrufs erheblich reduziert.

Hinweise für Aufrufer

In .NET Framework 3.5- und früheren Versionen verwendet die Methode, wenn die Split(Char[]) Methode keine separator null Zeichen enthält oder keine Zeichen enthält, eine geringfügig andere Gruppe von Leerzeichen, um die Zeichenfolge zu teilen als die Trim(Char[]) Methode, um die Zeichenfolge zu kürzen. Ab .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.

Gilt für:

Split(String, Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand einer angegebenen Trennzeichenfolge und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

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()

Parameter

separator
String

Eine Zeichenfolge, die die Teilzeichenfolgen in dieser Instanz trennt.

count
Int32

Die maximale Anzahl der im Array erwarteten Elemente.

options
StringSplitOptions

Dies ist eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen zugeschnitten und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, das maximal count Teilzeichenfolgen von dieser Instanz enthält, die durch separator getrennt sind.

Hinweise

Wenn die Zeichenfolge bereits geteilt count wurde - 1 Mal, aber das Ende der Zeichenfolge nicht erreicht wurde, enthält die letzte Zeichenfolge im zurückgegebenen Array die verbleibende nachgestellte Teilzeichenfolge dieser Instanz, unberührt.

Gilt für:

Split(Char[], StringSplitOptions)

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen und der Optionen in Teilzeichenfolgen unterteilt.

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()

Parameter

separator
Char[]

Hierbei handelt es sich um ein Array von Zeichen, die die Teilzeichenfolgen dieser Zeichenfolge trennen, ein leeres Array ohne Trennzeichen oder null.

options
StringSplitOptions

Dies ist eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen zugeschnitten und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen in dieser Zeichenfolge enthält, die durch ein oder mehr Zeichen aus separator getrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Attribute

Ausnahmen

options entspricht keinem der StringSplitOptions-Werte.

Beispiele

Im folgenden Beispiel wird die Aufzählung verwendet, um Teilzeichenfolgen einzuschließen oder auszuschließen, die StringSplitOptions von der Split Methode generiert werden.

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

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
 
// Display the array of separated strings using a local function
let show  (entries: string[]) =
    printfn $"The return value contains these {entries.Length} elements:"
    for entry in entries do
        printf $"<{entry}>"
    printf "\n\n"

let s1 = ",ONE,,TWO,,,THREE,,"
let s2 = "[stop]" +
         "ONE[stop][stop]" +
         "TWO[stop][stop][stop]" +
         "THREE[stop][stop]"
let charSeparators = [| ',' |]
let stringSeparators = [| "[stop]" |]
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
printfn "1) Split a string delimited by characters:\n"

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

// Split a string delimited by characters and return all elements.
printfn "1b) Split a string delimited by characters and return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result

// Split a string delimited by characters and return all non-empty elements.
printfn "1c) Split a string delimited by characters and return all non-empty elements:"
let 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.
printfn "1d) Split a string delimited by characters and return 2 elements:"
let 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.
printfn "1e) Split a string delimited by characters and return 2 non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
printfn "2) Split a string delimited by another string:\n"

// Display the original string and delimiter string.
printfn $"2a) The original string is \"{s2}\"."
printfn $"The delimiter string is \"{stringSeparators[0]}\".\n"

// Split a string delimited by another string and return all elements.
printfn "2b) Split a string delimited by another string and return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result

// Split the original string at the delimiter and return all non-empty elements.
printfn "2c) Split a string delimited by another string and return all non-empty elements:"
let 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.
printfn "2d) Split a string delimited by another string and return 2 elements:"
let 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.
printfn "2e) Split a string delimited by another string and return 2 non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

(*
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]>
'

Hinweise

Trennzeichen (die Zeichen im Array) sind nicht in separator die Elemente des zurückgegebenen Arrays enthalten. Wenn das Array beispielsweise das Zeichen "-" enthält und der Wert der aktuellen Zeichenfolgeninstanz "aa-bb-cc" lautet, gibt die separator Methode ein Array zurück, das drei Elemente enthält: "aa", "bb", und "cc".

Wenn diese Instanz keine der Zeichen enthält separator, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

Wenn der Parameter und die Länge dieser Instanz null istRemoveEmptyEntries, gibt die options Methode ein leeres Array zurück.

Jedes Element definiert separator ein separates Trennzeichen, das aus einem einzelnen Zeichen besteht. Wenn das Argument Noneist, und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält String.Emptydas options entsprechende Arrayelement . Wenn separator beispielsweise zwei Elemente '-' enthalten sind und '_'der Wert der Zeichenfolgeninstanz "-_aa"_, und der Wert des options Arguments lautet None, gibt die Methode ein Zeichenfolgenarray mit den folgenden fünf Elementen zurück:

  1. String.Empty, die die leere Zeichenfolge darstellt, die dem "-"-Zeichen bei Index 0 vorangestellt ist.

  2. String.Empty, die die leere Zeichenfolge zwischen dem "-"-Zeichen bei Index 0 und dem "_"-Zeichen bei Index 1 darstellt.

  3. "aa".

  4. String.Empty, die die leere Zeichenfolge darstellt, die dem "-"-Zeichen bei Index 4 folgt.

  5. String.Empty, die die leere Zeichenfolge darstellt, die dem "_"-Zeichen bei Index 5 folgt.

Das Trennzeichenarray

Wenn der separator Parameter keine Zeichen enthält null , werden Leerzeichen als Trennzeichen angenommen. Leerzeichen werden durch den Unicode-Standard definiert, und die Char.IsWhiteSpace Methode gibt true zurück, wenn sie an sie übergeben werden.

Um den Parameter zu übergeben null , müssen Sie den Typ des char[] separator null Aufrufs von einigen anderen Überladungen angeben, z Split(String[], StringSplitOptions). B. . Im folgenden Beispiel werden verschiedene Möglichkeiten gezeigt, diese Überladung eindeutig zu identifizieren.

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);
let phrase = "The quick  brown fox"

phrase.Split(Unchecked.defaultof<char[]>, StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split(null :> char[], StringSplitOptions.RemoveEmptyEntries) |> ignore

phrase.Split((null: char[]), StringSplitOptions.RemoveEmptyEntries) |> ignore
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)

Vergleichsdetails

Die Split Methode extrahiert die Unterzeichenfolgen in dieser Zeichenfolge, die durch eine oder mehrere Zeichen im separator Parameter getrennt sind, und gibt diese Unterzeichenfolgen als Elemente eines Arrays zurück.

Die Split Methode sucht nach Trennzeichen, indem Vergleiche mithilfe von Groß-/Kleinschreibungs-Sortierregeln ausgeführt werden. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordinalsortierungen finden Sie in der System.Globalization.CompareOptions Aufzählung.

Überlegungen zur Leistung

Die Split Methoden weisen Speicher für das zurückgegebene Arrayobjekt und ein String Objekt für jedes Arrayelement zu. Wenn Ihre Anwendung optimale Leistung erfordert oder wenn die Verwaltung der Speicherzuweisung in Ihrer Anwendung wichtig ist, sollten Sie die Verwendung IndexOf der IndexOfAny Methode und optional die Compare Methode verwenden, um eine Teilzeichenfolge in einer Zeichenfolge zu suchen.

Wenn Sie eine Zeichenfolge in einem Trennzeichen teilen, verwenden Sie die IndexOf IndexOfAny Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge bei einer Trennzeichenzeichenfolge teilen, verwenden Sie die IndexOf IndexOfAny methode, um das erste Zeichen der Trennzeichenzeichenfolge zu suchen. Verwenden Sie dann die Compare Methode, um zu bestimmen, ob die Zeichen nach diesem ersten Zeichen den verbleibenden Zeichen der Trennzeichenzeichenfolge entsprechen.

Wenn außerdem dieselbe Zeichenmenge zum Teilen von Zeichenfolgen in mehreren Split Methodenaufrufen verwendet wird, sollten Sie ein einzelnes Array erstellen und in jedem Methodenaufruf darauf verweisen. Dadurch wird der zusätzliche Aufwand jedes Methodenaufrufs erheblich reduziert.

Hinweise für Aufrufer

In .NET Framework 3.5- und früheren Versionen verwendet die Methode, wenn die Split(Char[]) Methode keine separator null Zeichen enthält oder keine Zeichen enthält, eine geringfügig andere Gruppe von Leerzeichen, um die Zeichenfolge zu teilen als die Trim(Char[]) Methode, um die Zeichenfolge zu kürzen. Ab .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.

Gilt für:

Split(Char[], Int32)

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen in eine maximale Anzahl von Teilzeichenfolgen unterteilt.

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()

Parameter

separator
Char[]

Hierbei handelt es sich um ein Array von Zeichen, die die Teilzeichenfolgen dieser Zeichenfolge trennen, ein leeres Array ohne Trennzeichen oder null.

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen in dieser Instanz enthält, die durch ein oder mehr Zeichen aus separator getrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Ausnahmen

count ist ein negativer Wert.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie count die Anzahl der von Splitihnen zurückgegebenen Zeichenfolgen eingeschränkt werden kann.

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"
let name = "Alex Johnson III"

let subs = name.Split(null, 2)

let firstName = subs[0]
let lastName =
    if subs.Length > 1 then
        subs[1]
    else
        ""

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

Hinweise

Trennzeichen sind nicht in die Elemente des zurückgegebenen Arrays enthalten.

Wenn diese Instanz keine der Zeichen enthält separator, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält. Wenn count null ist, wird ein leeres Array zurückgegeben.

Wenn der separator Parameter keine Zeichen enthält null , werden Leerzeichen als Trennzeichen angenommen. Leerzeichen werden durch den Unicode-Standard definiert, und die Char.IsWhiteSpace Methode gibt true zurück, wenn sie an sie übergeben werden.

Jedes Element definiert separator ein separates Trennzeichen. Wenn zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält Emptydas entsprechende Arrayelement .

Wenn in dieser Instanz mehr count als Teilzeichenfolgen vorhanden sind, werden die ersten Teilzeichenfolgen in den ersten count - 1 count - 1 Elementen des Rückgabewerts zurückgegeben, und die verbleibenden Zeichen in dieser Instanz werden im letzten Element des Rückgabewerts zurückgegeben.

Wenn count die Anzahl der Unterzeichenfolgen größer ist, werden die verfügbaren Unterzeichenfolgen zurückgegeben und keine Ausnahme ausgelöst.

In der folgenden Tabelle sind einige Beispiele aufgeführt.

Sprache Zeichenfolgenwert Trennzeichen Zurückgegebenes Array
C# "42, 12, 19" new Char[] {',', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char() = {","c, " "c}" {"42", "", "12", "", "19"}
C# "42..12..19." neues Char[] {'.'} {"42", "", "12", "", "19", ""}
Visual Basic "42..12..19." Char() = {"." c} {"42", "", "12", "", "19", ""}
C# "Bananen" neues Char[] {'.'} {"Banana"}
Visual Basic "Bananen" Char() = {"." c} {"Banana"}
C# "Darb\nSmarba" neues Char[] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char() = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" NULL {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nichts {"Darb", "Smarba"}

Überlegungen zur Leistung

Die Split Methoden weisen Speicher für das zurückgegebene Arrayobjekt und ein String Objekt für jedes Arrayelement zu. Wenn Ihre Anwendung optimale Leistung erfordert oder wenn die Verwaltung der Speicherzuweisung in Ihrer Anwendung wichtig ist, sollten Sie die Verwendung IndexOf der IndexOfAny Methode und optional die Compare Methode verwenden, um eine Teilzeichenfolge in einer Zeichenfolge zu suchen.

Wenn Sie eine Zeichenfolge in einem Trennzeichen teilen, verwenden Sie die IndexOf IndexOfAny Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge bei einer Trennzeichenzeichenfolge teilen, verwenden Sie die IndexOf IndexOfAny methode, um das erste Zeichen der Trennzeichenzeichenfolge zu suchen. Verwenden Sie dann die Compare Methode, um zu bestimmen, ob die Zeichen nach diesem ersten Zeichen den verbleibenden Zeichen der Trennzeichenzeichenfolge entsprechen.

Wenn außerdem dieselbe Zeichenmenge zum Teilen von Zeichenfolgen in mehreren Split Methodenaufrufen verwendet wird, sollten Sie ein einzelnes Array erstellen und in jedem Methodenaufruf darauf verweisen. Dadurch wird der zusätzliche Aufwand jedes Methodenaufrufs erheblich reduziert.

Hinweise für Aufrufer

In .NET Framework 3.5- und früheren Versionen verwendet die Methode, wenn die Split(Char[]) Methode keine separator null Zeichen enthält oder keine Zeichen enthält, eine geringfügig andere Gruppe von Leerzeichen, um die Zeichenfolge zu teilen als die Trim(Char[]) Methode, um die Zeichenfolge zu kürzen. Ab .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.

Siehe auch

Gilt für:

Split(Char, StringSplitOptions)

Hier wird eine Zeichenfolge anhand eines angegebenen Trennzeichens und optional von Optionen in Teilzeichenfolgen unterteilt.

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()

Parameter

separator
Char

Ein Zeichen, das die Teilzeichenfolgen in dieser Zeichenfolge trennt.

options
StringSplitOptions

Dies ist eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen zugeschnitten und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen von dieser Instanz enthält, die durch separator getrennt sind.

Gilt für:

Split(String, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in Teilzeichenfolgen.

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()

Parameter

separator
String

Eine Zeichenfolge, die die Teilzeichenfolgen in dieser Zeichenfolge trennt.

options
StringSplitOptions

Dies ist eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen zugeschnitten und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen von dieser Instanz enthält, die durch separator getrennt sind.

Gilt für:

Split(Char[])

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen in Teilzeichenfolgen unterteilt.

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()

Parameter

separator
Char[]

Ein Array von Trennzeichen, ein leeres Array, das keine Trennzeichen enthält, oder null.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen von dieser Instanz enthält, die durch ein oder mehr Zeichen aus separator getrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie einzelne Wörter aus einem Textblock extrahiert werden, indem das Leerzeichen () und das Tabstoppzeichen () als Trennzeichen ( ``\t) behandelt werden. Die Zeichenfolge, die geteilt wird, enthält beide dieser Zeichen.

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
let s = "Today\tI'm going to school"
let subs = s.Split(' ', '\t')

for sub in subs do
    printfn $"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

Hinweise

Wenn eine Zeichenfolge durch einen bekannten Satz von Zeichen getrennt wird, können Sie die Split(Char[]) Methode verwenden, um sie in Unterzeichenfolgen zu trennen.

Trennzeichen sind nicht in die Elemente des zurückgegebenen Arrays enthalten. Wenn beispielsweise das Trennzeichenarray das Zeichen "-" enthält und der Wert der aktuellen Zeichenfolgeninstanz "aa-bb-cc" lautet, gibt die Methode ein Array zurück, das drei Elemente enthält: "aa", "bb" und "cc".

Wenn diese Instanz keine der Zeichen enthält separator, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

Jedes Element definiert separator ein separates Trennzeichen. Wenn zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält Emptydas entsprechende Element im zurückgegebenen Array .

In der folgenden Tabelle sind einige Beispiele aufgeführt.

Sprache Zeichenfolgenwert Trennzeichen Zurückgegebenes Array
C# "42, 12, 19" new Char[] {',', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char() = {","c, " "c}" {"42", "", "12", "", "19"}
C# "42..12..19." neues Char[] {'.'} {"42", "", "12", "", "19", ""}
Visual Basic "42..12..19." Char() = {"." c} {"42", "", "12", "", "19", ""}
C# "Bananen" neues Char[] {'.'} {"Banana"}
Visual Basic "Bananen" Char() = {"." c} {"Banana"}
C# "Darb\nSmarba" neues Char[] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char() = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" NULL {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nichts {"Darb", "Smarba"}

Das Trennzeichenarray

Jedes Element des Trennzeichens definiert ein separates Trennzeichen, das aus einem einzelnen Zeichen besteht.

Wenn das Argument keine Zeichen enthältnull, behandelt die separator Methode Leerzeichen als Trennzeichen. Leerzeichen werden durch den Unicode-Standard definiert, und die Char.IsWhiteSpace Methode gibt true zurück, wenn ein Leerzeichen an ihn übergeben wird.

String.Split(Char[]) und Compilerüberladungsauflösung

Obwohl der einzelne Parameter für diese Überladung ein Zeichenarray String.Split ist, können Sie ihn mit einem einzelnen Zeichen aufrufen, wie das folgende Beispiel zeigt.

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.
let value = "This is a short string."
let delimiter = 's'
let substrings = value.Split delimiter
for substring in substrings do
    printfn $"{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.

Da der separator Parameter mit dem ParamArrayAttribute Attribut versehen ist, interpretiert Compiler ein einzelnes Zeichen als Ein-Element-Zeichenarray. Dies ist nicht der Fall für andere String.Split Überladungen, die einen separator Parameter enthalten; Sie müssen diese Überladungen explizit als separator Argument übergeben.

Vergleichsdetails

Die Split(Char[]) Methode extrahiert die Unterzeichenfolgen in dieser Zeichenfolge, die durch eine oder mehrere Zeichen im separator Array getrennt sind, und gibt diese Unterzeichenfolgen als Elemente eines Arrays zurück.

Die Split(Char[]) Methode sucht nach Trennzeichen, indem Vergleiche mithilfe von Groß-/Kleinschreibungs-Sortierregeln ausgeführt werden. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordinalsortierungen finden Sie in der System.Globalization.CompareOptions Aufzählung.

Überlegungen zur Leistung

Die Split Methoden weisen Speicher für das zurückgegebene Arrayobjekt und ein String Objekt für jedes Arrayelement zu. Wenn Ihre Anwendung optimale Leistung erfordert oder wenn die Verwaltung der Speicherzuweisung in Ihrer Anwendung wichtig ist, sollten Sie die IndexOf Verwendung oder IndexOfAny Methode verwenden. Sie haben auch die Möglichkeit, die Compare Methode zum Suchen einer Unterzeichenfolge in einer Zeichenfolge zu verwenden.

Um eine Zeichenfolge bei einem Trennzeichen zu teilen, verwenden Sie die IndexOf IndexOfAny oder methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Um eine Zeichenfolge bei einer Trennzeichenzeichenfolge zu teilen, verwenden Sie die IndexOf oder IndexOfAny methode, um das erste Zeichen der Trennzeichenzeichenfolge zu suchen. Verwenden Sie dann die Compare Methode, um zu bestimmen, ob die Zeichen nach diesem ersten Zeichen den verbleibenden Zeichen der Trennzeichenzeichenfolge entsprechen.

Wenn außerdem dieselbe Zeichenmenge zum Teilen von Zeichenfolgen in mehreren Split Methodenaufrufen verwendet wird, sollten Sie ein einzelnes Array erstellen und in jedem Methodenaufruf darauf verweisen. Dadurch wird der zusätzliche Aufwand jedes Methodenaufrufs erheblich reduziert.

Hinweise für Aufrufer

In .NET Framework 3.5- und früheren Versionen verwendet die Methode, wenn die Split(Char[]) Methode keine separator null Zeichen enthält oder keine Zeichen enthält, eine geringfügig andere Gruppe von Leerzeichen, um die Zeichenfolge zu teilen als die Trim(Char[]) Methode, um die Zeichenfolge zu kürzen. Ab .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.

Siehe auch

Gilt für: