String.Split Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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

Überlädt

Split(String, Int32, StringSplitOptions)	Teilt eine Zeichenfolge auf der Grundlage einer angegebenen Trennzeichenfolge und optional optionen in eine maximale Anzahl von Teilzeichenfolgen auf.
Split(Char[], Int32, StringSplitOptions)	Teilt eine Zeichenfolge in eine maximale Anzahl von Teilzeichenfolgen basierend auf angegebenen Trennzeichen und optional Optionen auf.
Split(Char, Int32, StringSplitOptions)	Teilt eine Zeichenfolge auf der Grundlage eines angegebenen Trennzeichens und optional optionen in eine maximale Anzahl von Teilzeichenfolgen auf. Teilt eine Zeichenfolge auf der Grundlage des bereitgestellten Zeichentrennzeichens in eine maximale Anzahl von Teilzeichenfolgen auf, wobei leere Teilzeichenfolgen aus dem Ergebnis weggelassen werden.
Split(String[], StringSplitOptions)	Teilt eine Zeichenfolge basierend auf einer angegebenen Trennzeichenzeichenfolge und optional optionen in Teilzeichenfolgen auf.
Split(String, StringSplitOptions)	Teilt eine Zeichenfolge in Teilzeichenfolgen auf, die auf dem bereitgestellten Zeichenfolgentrennzeichen basieren.
Split(Char[])	Teilt eine Zeichenfolge basierend auf angegebenen Trennzeichen in Teilzeichenfolgen auf.
Split(Char[], Int32)	Teilt eine Zeichenfolge auf der Grundlage der angegebenen Trennzeichen in eine maximale Anzahl von Teilzeichenfolgen auf.
Split(Char, StringSplitOptions)	Teilt eine Zeichenfolge basierend auf einem angegebenen Trennzeichen und optional optionen in Teilzeichenfolgen auf.
Split(ReadOnlySpan<Char>)	Teilt eine Zeichenfolge basierend auf angegebenen Trennzeichen in Teilzeichenfolgen auf.
Split(String[], Int32, StringSplitOptions)	Teilt eine Zeichenfolge in eine maximale Anzahl von Teilzeichenfolgen basierend auf angegebenen Trennzeichenzeichenfolgen und optional Optionen auf.
Split(Char[], StringSplitOptions)	Teilt eine Zeichenfolge basierend auf angegebenen Trennzeichen und Optionen in Teilzeichenfolgen auf.

Hinweise

Split wird verwendet, um eine durch Trennzeichen getrennte Zeichenfolge in Teilzeichenfolgen aufzuteilen. 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 bei Leerzeichen aufgeteilt.

Überladungen der Split-Methode ermöglichen es Ihnen, die Anzahl der von der Methode zurückgegebenen Teilzeichenfolgen (die Split(Char[], Int32)-Methode) einzuschränken, um anzugeben, ob leere Zeichenfolgen und/oder Teilzeichenfolgen in das Ergebnis (die methoden Split(Char[], StringSplitOptions) und Split(String[], StringSplitOptions)) oder beides (die Split(Char[], Int32, StringSplitOptions)- und Split(String[], Int32, StringSplitOptions)-Methoden) eingeschlossen werden sollen.

Trinkgeld

Die Split-Methode ist nicht immer die beste Methode, um eine durch Trennzeichen getrennte Zeichenfolge in Teilzeichenfolgen aufzuteilen. Wenn Sie nicht alle Teilzeichenfolgen einer durch Trennzeichen getrennten Zeichenfolge extrahieren oder eine Zeichenfolge basierend auf einem Muster statt einer Gruppe 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 Teilzeichenfolgen aus einer Zeichenfolge.

Beispiel

Die folgenden Beispiele zeigen drei verschiedene Überladungen von String.Split(). Im ersten Beispiel wird die Split(Char[]) Überladung aufgerufen und ein einzelnes 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. Das nächste Beispiel zeigt, 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 Perioden stammen aus den Teilzeichenfolgen, aber jetzt wurden zwei zusätzliche leere Teilzeichenfolgen einbezogen. Diese leere Teilzeichenfolge stellt die Teilzeichenfolge zwischen einem Wort und dem darauf folgenden Punkt dar. Um leere Teilzeichenfolgen aus dem resultierenden Array auszulassen, können Sie die Split(Char[], StringSplitOptions)-Überladung aufrufen und StringSplitOptions.RemoveEmptyEntries für den options-Parameter 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 von String.Split() enthalten weitere Beispiele.

Split(String, Int32, StringSplitOptions)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge auf der Grundlage einer angegebenen Trennzeichenfolge und optional optionen in eine maximale Anzahl von Teilzeichenfolgen auf.

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 abgrenzt.

count: Int32

Die maximale Anzahl von Elementen, die im Array erwartet werden.

options: StringSplitOptions

Eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen gekürzt und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, das höchstens count Teilzeichenfolgen aus dieser Instanz enthält, die durch separatorgetrennt sind.

Hinweise

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

Gilt für:

Split(Char[], Int32, StringSplitOptions)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge in eine maximale Anzahl von Teilzeichenfolgen basierend auf angegebenen Trennzeichen und optional Optionen auf.

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

Ein Array von Zeichen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array, das keine Trennzeichen enthält, oder null.

count: Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

options: StringSplitOptions

Eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen gekürzt und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

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

Attribute: ComVisibleAttribute

Ausnahmen

ArgumentOutOfRangeException

count ist negativ.

ArgumentException

options gehört nicht zu den StringSplitOptions Werten.

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.

// Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:\n");

string s1 = ",ONE,, TWO,, , THREE,,";
char[] charSeparators = new char[] { ',' };
string[] result;

Console.WriteLine($"The original string is: \"{s1}\".");
Console.WriteLine($"The delimiter character is: '{charSeparators[0]}'.\n");

// Split the string and return all elements
Console.WriteLine("1a) Return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries);
Show(result);

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

// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);

// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


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

string s2 = "[stop]" +
            "ONE[stop] [stop]" +
            "TWO  [stop][stop]  [stop]" +
            "THREE[stop][stop]  ";
string[] stringSeparators = new string[] { "[stop]" };

Console.WriteLine($"The original string is: \"{s2}\".");
Console.WriteLine($"The delimiter string is: \"{stringSeparators[0]}\".\n");

// Split the string and return all elements
Console.WriteLine("2a) Return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries);
Show(result);

// Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);

// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
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:

The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.

1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>

1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>

1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>

1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>

2) Split a string delimited by another string:

The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
The delimiter string is: "[stop]".

2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO  ><><  ><THREE><><  >

2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO  ><  ><THREE><  >

2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>

2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2h) Split into only two non-whitespace elements with whitespace trimmed:
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"

// Example 1: Split a string delimited by characters
printfn "1) Split a string delimited by characters:\n"

let s1 = ",ONE,, TWO,, , THREE,,"
let charSeparators = [| ',' |]

printfn $"The original string is: \"{s1}\"."
printfn $"The delimiter character is: '{charSeparators[0]}'.\n"

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

// Split the string and return all elements with whitespace trimmed
printfn "1b) Return all elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
show result

// Split the string and return all non-empty elements
printfn "1c) Return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "1d) Return all non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


// Split the string into only two elements, keeping the remainder in the last match
printfn "1e) Split into only two elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.None)
show result

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "1f) Split into only two elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
show result

// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "1g) Split into only two non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "1h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


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

let s2 = "[stop]" +
            "ONE[stop] [stop]" +
            "TWO  [stop][stop]  [stop]" +
            "THREE[stop][stop]  "
let stringSeparators = [| "[stop]" |]

printfn $"The original string is: \"{s2}\"."
printfn $"The delimiter string is: \"{stringSeparators[0]}\".\n"

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

// Split the string and return all elements with whitespace trimmed
printfn "2b) Return all elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
show result

// Split the string and return all non-empty elements
printfn "2c) Return all non-empty elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "2d) Return all non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


// Split the string into only two elements, keeping the remainder in the last match
printfn "2e) Split into only two elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
show result

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "2f) Split into only two elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
show result

// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "2g) Split into only two non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "2h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result

(*
This example produces the following results:

1) Split a string delimited by characters:

The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.

1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>

1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>

1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>

1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>

2) Split a string delimited by another string:

The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
The delimiter string is: "[stop]".

2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO  ><><  ><THREE><><  >

2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO  ><  ><THREE><  >

2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>

2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO  [stop][stop]  [stop]THREE[stop][stop]>

*)

Public Shared Sub StringSplitOptionsExamples()
    ' This example demonstrates the String.Split() methods that use
    ' the StringSplitOptions enumeration.

    ' Example 1: Split a string delimited by characters
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    Dim s1 As String = ",ONE,, TWO,, , THREE,,"
    Dim charSeparators() As Char = {","c}
    Dim result() As String

    Console.WriteLine("The original string is: ""{0}"".", s1)
    Console.WriteLine("The delimiter character is: '{0}'." & vbCrLf, charSeparators(0))

    ' Split the string and return all elements
    Console.WriteLine("1a) Return all elements:")
    result = s1.Split(charSeparators, StringSplitOptions.None)
    Show(result)

    ' Split the string and return all elements with whitespace trimmed
    Console.WriteLine("1b) Return all elements with whitespace trimmed:")
    result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string and return all non-empty elements
    Console.WriteLine("1c) Return all non-empty elements:")
    result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string and return all non-whitespace elements with whitespace trimmed
    Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:")
    result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


    ' Split the string into only two elements, keeping the remainder in the last match
    Console.WriteLine("1e) Split into only two elements:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.None)
    Show(result)

    ' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("1f) Split into only two elements with whitespace trimmed:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string into only two non-empty elements, keeping the remainder in the last match
    Console.WriteLine("1g) Split into only two non-empty elements:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


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

    Dim s2 As String = "[stop]" +
                "ONE[stop] [stop]" +
                "TWO  [stop][stop]  [stop]" +
                "THREE[stop][stop]  "
    Dim stringSeparators() As String = {"[stop]"}


    Console.WriteLine("The original string is: ""{0}"".", s2)
    Console.WriteLine("The delimiter string is: ""{0}""." & vbCrLf, stringSeparators(0))

    ' Split the string and return all elements
    Console.WriteLine("2a) Return all elements:")
    result = s2.Split(stringSeparators, StringSplitOptions.None)
    Show(result)

    ' Split the string and return all elements with whitespace trimmed
    Console.WriteLine("2b) Return all elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string and return all non-empty elements
    Console.WriteLine("2c) Return all non-empty elements:")
    result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string and return all non-whitespace elements with whitespace trimmed
    Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


    ' Split the string into only two elements, keeping the remainder in the last match
    Console.WriteLine("2e) Split into only two elements:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
    Show(result)

    ' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("2f) Split into only two elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string into only two non-empty elements, keeping the remainder in the last match
    Console.WriteLine("2g) Split into only two non-empty elements:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    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:
'
' The original string is: ",ONE,, TWO,, , THREE,,".
' The delimiter character is: ','.
'
' 1a) Return all elements:
' The return value contains these 9 elements:
' <><ONE><>< TWO><>< >< THREE><><>
'
' 1b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 1c) Return all non-empty elements:
' The return value contains these 4 elements:
' <ONE>< TWO>< >< THREE>
'
' 1d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 1e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< TWO,, , THREE,,>
'
' 1h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO,, , THREE,,>
'
' 2) Split a string delimited by another string:
'
' The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
' The delimiter string is: "[stop]".
'
' 2a) Return all elements:
' The return value contains these 9 elements:
' <><ONE>< ><TWO  ><><  ><THREE><><  >
'
' 2b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 2c) Return all non-empty elements:
' The return value contains these 6 elements:
' <ONE>< ><TWO  ><  ><THREE><  >
'
' 2d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 2e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >
'
' 2f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>
'
' 2g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >
'
' 2h) Split into only two non-whitespace elements with whitespace trimmed:
' 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 in separatorenthält oder der parameter count 1 ist, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

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

Um null für den char[] separator-Parameter zu übergeben, müssen Sie den Typ des null angeben, um den Aufruf von einigen anderen Überladungen zu unterscheiden, z. B. Split(String[], Int32, StringSplitOptions). 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 parameter count null ist oder der parameter optionsRemoveEmptyEntries und die Länge dieser Instanz null ist, wird ein leeres Array zurückgegeben.

Jedes Element von separator definiert ein separates Trennzeichen. Wenn der parameter optionsNoneist und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Arrayelement Empty.

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

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

Leistungsüberlegungen

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

Wenn Sie eine Zeichenfolge auf ein Trennzeichen aufteilen, verwenden Sie die IndexOf- oder IndexOfAny Methode, 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 Satz von Zeichen zum Aufteilen von Zeichenfolgen in mehreren Split Methodenaufrufen verwendet wird, sollten Sie in Betracht ziehen, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen. Dadurch wird der zusätzliche Aufwand für jeden Methodenaufruf erheblich reduziert.

Hinweise für Aufrufer

Wenn die Split(Char[]) Methode in .NET Framework 3.5 und früheren Versionen eine separator übergeben wird, die null ist oder keine Zeichen enthält, verwendet die Methode einen etwas anderen Satz leerer Zeichen, um die Zeichenfolge aufzuteilen 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)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge auf der Grundlage eines angegebenen Trennzeichens und optional optionen in eine maximale Anzahl von Teilzeichenfolgen auf. Teilt eine Zeichenfolge auf der Grundlage des bereitgestellten Zeichentrennzeichens in eine maximale Anzahl von Teilzeichenfolgen auf, wobei leere Teilzeichenfolgen aus dem Ergebnis weggelassen 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 abgrenzt.

count: Int32

Die maximale Anzahl von Elementen, die im Array erwartet werden.

options: StringSplitOptions

Eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen gekürzt und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, das höchstens count Teilzeichenfolgen aus dieser Instanz enthält, die durch separatorgetrennt sind.

Hinweise

Gilt für:

Split(String[], StringSplitOptions)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge basierend auf einer angegebenen Trennzeichenzeichenfolge und optional optionen in Teilzeichenfolgen auf.

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

Ein Array von Zeichenfolgen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array, das keine Trennzeichen enthält, oder null.

options: StringSplitOptions

Eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen gekürzt und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen in dieser Zeichenfolge enthalten, die durch eine oder mehrere Zeichenfolgen in separatorgetrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Attribute: ComVisibleAttribute

Ausnahmen

ArgumentException

options gehört nicht zu den StringSplitOptions Werten.

Beispiele

Im folgenden Beispiel wird der Unterschied in den Arrays veranschaulicht, die durch Aufrufen der String.Split(String[], StringSplitOptions) -Methode einer Zeichenfolge mit dem options-Parameter StringSplitOptions.None und StringSplitOptions.RemoveEmptyEntrieszurückgegeben werden.

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 Interpunktionszeichen und Leerzeichen enthalten. Wenn Sie dieses Array zusammen mit einem Wert von StringSplitOptions.RemoveEmptyEntries an die Split(String[], StringSplitOptions)-Methode übergeben, wird ein Array zurückgegeben, das aus den einzelnen Wörtern aus der 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 aufgerufen wird, wobei das argument options auf StringSplitOptions.RemoveEmptyEntriesfestgelegt ist. Dadurch wird verhindert, dass das zurückgegebene Array String.Empty Werte einschlugt, die leere Teilzeichenfolgenüberstimmungen zwischen Satzzeichen 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 Teilzeichenfolgen zu trennen.

Trennzeichenzeichenfolgen sind nicht in den Elementen des zurückgegebenen Arrays enthalten. Wenn das separator Array beispielsweise 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 in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

Wenn der parameter optionsRemoveEmptyEntries und die Länge dieser Instanz null ist, gibt die Methode ein leeres Array zurück.

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

String.Empty, die die leere Zeichenfolge darstellt, die der Teilzeichenfolge "-" bei Index 0 vorangestellt ist.
String.Empty, die die leere Zeichenfolge zwischen der Teilzeichenfolge "-" bei Index 0 und der Teilzeichenfolge "_" bei Index 1 darstellt.
"aa".
String.Empty, die die leere Zeichenfolge darstellt, die auf die Teilzeichenfolge "-" bei Index 4 folgt.
String.Empty, die die leere Zeichenfolge darstellt, die auf die Teilzeichenfolge "_" bei Index 5 folgt.

Das Trennzeichenarray

Wenn eines der Elemente in separator aus mehreren Zeichen besteht, wird die gesamte Teilzeichenfolge als Trennzeichen betrachtet. Wenn beispielsweise eines der Elemente in separator "10" lautet, wird versucht, die Zeichenfolge "This10is10a10string" aufzuteilen. Gibt das folgende Array mit vier Elementen zurück: { "This", "is", "a", "string." }.

Wenn der parameter separatornull ist oder keine nicht leeren Zeichenfolgen enthält, werden Leerzeichen als Trennzeichen angenommen. Leerzeichen werden vom Unicode-Standard definiert, und die Char.IsWhiteSpace-Methode gibt true zurück, wenn sie an ihn übergeben werden.

Um null für den string[] separator-Parameter zu übergeben, müssen Sie den Typ des null angeben, um den Aufruf von einigen anderen Überladungen zu unterscheiden, z. B. Split(Char[], StringSplitOptions). Das folgende Beispiel zeigt mehrere Möglichkeiten, um 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 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 Sortierregeln unter Beachtung der 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 von separator, dessen Wert null oder die leere Zeichenfolge ("").

Um mehrdeutige Ergebnisse zu vermeiden, wenn Zeichenfolgen in separator Zeichen gemeinsam haben, wird der Split Vorgang vom Anfang bis zum Ende des Werts der Instanz fortgesetzt und entspricht dem ersten Element in separator, 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.

Betrachten Sie beispielsweise eine Instanz, deren Wert "abcdef" lautet. Wenn das erste Element in separator "ef" lautete und das zweite Element "bcde" lautete, wäre das Ergebnis des Geteilten Vorgangs ein Zeichenfolgenarray, das zwei Elemente enthält: "a" und "f". Dies liegt daran, dass die Teilzeichenfolge in der Instanz "bcde" gefunden wird und mit einem Element in separator übereinstimmt, bevor die Teilzeichenfolge "f" gefunden wird.

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

Leistungsüberlegungen

Hinweise für Aufrufer

Gilt für:

Split(String, StringSplitOptions)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge in Teilzeichenfolgen auf, die auf dem bereitgestellten Zeichenfolgentrennzeichen basieren.

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 abgrenzt.

options: StringSplitOptions

Eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen gekürzt und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen aus dieser Instanz enthalten, die durch separatorgetrennt sind.

Gilt für:

Split(Char[])

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge basierend auf angegebenen Trennzeichen in Teilzeichenfolgen auf.

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 mit Trennzeichen, ein leeres Array ohne Trennzeichen oder null.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen aus dieser Instanz enthalten, die durch ein oder mehrere Zeichen in separatorgetrennt 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 (\t) als Trennzeichen behandelt werden. Die geteilte Zeichenfolge enthält beide 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 Teilzeichenfolgen zu trennen.

Trennzeichen sind nicht in den Elementen des zurückgegebenen Arrays enthalten. Wenn das Trennzeichenarray beispielsweise 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 keines der Zeichen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

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

In der folgenden Tabelle sind einige Beispiele aufgeführt.

Sprache	Zeichenfolgenwert	Separator	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."	new Char[] {'.'}	{"42", "", "12", "", "19", ""}
Visual Basic	"42..12..19."	Char() = {"." c}	{"42", "", "12", "", "19", ""}
C#	"Banane"	new Char[] {'.'}	{"Banana"}
Visual Basic	"Banane"	Char() = {"." c}	{"Banana"}
C#	"Darb\nSmarba"	neue 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 separatornull ist oder keine Zeichen enthält, behandelt die Methode Leerzeichen als Trennzeichen. Leerzeichen werden vom 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 von String.Split ein Zeichenarray ist, können Sie ihn mit einem einzelnen Zeichen aufrufen, wie im folgenden Beispiel gezeigt.

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 attribut ParamArrayAttribute versehen ist, interpretiert compiler ein einzelnes Zeichen als ein elementbasiertes Zeichenarray. Dies ist nicht der Fall für andere String.Split-Überladungen, die einen separator-Parameter enthalten; Sie müssen diese Überladungen explizit als argument separator übergeben.

Vergleichsdetails

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

Die Split(Char[])-Methode sucht nach Trennzeichen, indem Vergleiche mithilfe von Sortierregeln unter Beachtung der Groß-/Kleinschreibung durchgeführt werden. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierungen finden Sie in der System.Globalization.CompareOptions Enumeration.

Leistungsüberlegungen

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

Um eine Zeichenfolge in einem Trennzeichen aufzuteilen, verwenden Sie die IndexOf- oder IndexOfAny Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge in einer Trennzeichenfolge aufteilen möchten, verwenden Sie die IndexOf- oder IndexOfAny Methode, um das erste Zeichen der Trennzeichenfolge zu finden. Verwenden Sie dann die Compare-Methode, um zu bestimmen, ob die Zeichen nach diesem ersten Zeichen den verbleibenden Zeichen der Trennzeichenfolge entsprechen.

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Split(Char[], Int32)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge auf der Grundlage der angegebenen Trennzeichen in eine maximale Anzahl von Teilzeichenfolgen auf.

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

Ein Array von Zeichen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array, das keine Trennzeichen enthält, oder null.

count: Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen in dieser Instanz enthalten, die durch ein oder mehrere Zeichen in separatorgetrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Ausnahmen

ArgumentOutOfRangeException

count ist negativ.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie count verwendet werden kann, um die Anzahl der von Splitzurückgegebenen Zeichenfolgen einzuschränken.

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(" "c, count:=2)
Dim firstName As String = substrings(0)
Dim lastName As String

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

Console.WriteLine("firstName = ""{0}""", firstName)
Console.WriteLine("lastName = ""{0}""", lastName)

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

Hinweise

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

Wenn diese Instanz keines der Zeichen in separatorenthält, 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 in dieser Instanz mehr als count Teilzeichenfolgen vorhanden sind, werden die ersten count - 1 Teilzeichenfolgen in den ersten count - 1 Elementen des Rückgabewerts zurückgegeben, und die übrigen Zeichen in dieser Instanz werden im letzten Element des Rückgabewerts zurückgegeben.

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

In der folgenden Tabelle sind einige Beispiele aufgeführt.

Sprache	Zeichenfolgenwert	Separator	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."	new Char[] {'.'}	{"42", "", "12", "", "19", ""}
Visual Basic	"42..12..19."	Char() = {"." c}	{"42", "", "12", "", "19", ""}
C#	"Banane"	new Char[] {'.'}	{"Banana"}
Visual Basic	"Banane"	Char() = {"." c}	{"Banana"}
C#	"Darb\nSmarba"	neue 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"}

Leistungsüberlegungen

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Split(Char, StringSplitOptions)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge basierend auf einem angegebenen Trennzeichen und optional optionen in Teilzeichenfolgen auf.

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 abgrenzt.

options: StringSplitOptions

Eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen gekürzt und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen aus dieser Instanz enthalten, die durch separatorgetrennt sind.

Gilt für:

Split(ReadOnlySpan<Char>)

Teilt eine Zeichenfolge basierend auf angegebenen Trennzeichen in Teilzeichenfolgen auf.

public:
 cli::array <System::String ^> ^ Split(ReadOnlySpan<char> separator);

public string[] Split (scoped ReadOnlySpan<char> separator);

member this.Split : ReadOnlySpan<char> -> string[]

Public Function Split (separator As ReadOnlySpan(Of Char)) As String()

Parameter

separator: ReadOnlySpan<Char>

Eine Spanne von Trennzeichen oder eine leere Spanne, die keine Trennzeichen enthält.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen aus dieser Instanz enthalten, die durch ein oder mehrere Zeichen in separatorgetrennt sind.

Gilt für:

Split(String[], Int32, StringSplitOptions)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge in eine maximale Anzahl von Teilzeichenfolgen basierend auf angegebenen Trennzeichenzeichenfolgen und optional Optionen auf.

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

Die Zeichenfolgen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array, das keine Trennzeichen enthält, oder null.

count: Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

options: StringSplitOptions

Eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen gekürzt und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Attribute: ComVisibleAttribute

Ausnahmen

ArgumentOutOfRangeException

count ist negativ.

ArgumentException

options gehört nicht zu den StringSplitOptions Werten.

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.

// Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:\n");

string s1 = ",ONE,, TWO,, , THREE,,";
char[] charSeparators = new char[] { ',' };
string[] result;

Console.WriteLine($"The original string is: \"{s1}\".");
Console.WriteLine($"The delimiter character is: '{charSeparators[0]}'.\n");

// Split the string and return all elements
Console.WriteLine("1a) Return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries);
Show(result);

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

// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);

// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


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

string s2 = "[stop]" +
            "ONE[stop] [stop]" +
            "TWO  [stop][stop]  [stop]" +
            "THREE[stop][stop]  ";
string[] stringSeparators = new string[] { "[stop]" };

Console.WriteLine($"The original string is: \"{s2}\".");
Console.WriteLine($"The delimiter string is: \"{stringSeparators[0]}\".\n");

// Split the string and return all elements
Console.WriteLine("2a) Return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries);
Show(result);

// Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);

// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
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:

The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.

1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>

1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>

1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>

1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>

2) Split a string delimited by another string:

The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
The delimiter string is: "[stop]".

2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO  ><><  ><THREE><><  >

2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO  ><  ><THREE><  >

2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>

2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2h) Split into only two non-whitespace elements with whitespace trimmed:
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"

// Example 1: Split a string delimited by characters
printfn "1) Split a string delimited by characters:\n"

let s1 = ",ONE,, TWO,, , THREE,,"
let charSeparators = [| ',' |]

printfn $"The original string is: \"{s1}\"."
printfn $"The delimiter character is: '{charSeparators[0]}'.\n"

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

// Split the string and return all elements with whitespace trimmed
printfn "1b) Return all elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
show result

// Split the string and return all non-empty elements
printfn "1c) Return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "1d) Return all non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


// Split the string into only two elements, keeping the remainder in the last match
printfn "1e) Split into only two elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.None)
show result

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "1f) Split into only two elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
show result

// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "1g) Split into only two non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "1h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


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

let s2 = "[stop]" +
            "ONE[stop] [stop]" +
            "TWO  [stop][stop]  [stop]" +
            "THREE[stop][stop]  "
let stringSeparators = [| "[stop]" |]

printfn $"The original string is: \"{s2}\"."
printfn $"The delimiter string is: \"{stringSeparators[0]}\".\n"

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

// Split the string and return all elements with whitespace trimmed
printfn "2b) Return all elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
show result

// Split the string and return all non-empty elements
printfn "2c) Return all non-empty elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "2d) Return all non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


// Split the string into only two elements, keeping the remainder in the last match
printfn "2e) Split into only two elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
show result

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "2f) Split into only two elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
show result

// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "2g) Split into only two non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "2h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result

(*
This example produces the following results:

1) Split a string delimited by characters:

The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.

1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>

1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>

1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>

1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>

2) Split a string delimited by another string:

The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
The delimiter string is: "[stop]".

2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO  ><><  ><THREE><><  >

2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO  ><  ><THREE><  >

2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>

2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO  [stop][stop]  [stop]THREE[stop][stop]>

*)

Public Shared Sub StringSplitOptionsExamples()
    ' This example demonstrates the String.Split() methods that use
    ' the StringSplitOptions enumeration.

    ' Example 1: Split a string delimited by characters
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    Dim s1 As String = ",ONE,, TWO,, , THREE,,"
    Dim charSeparators() As Char = {","c}
    Dim result() As String

    Console.WriteLine("The original string is: ""{0}"".", s1)
    Console.WriteLine("The delimiter character is: '{0}'." & vbCrLf, charSeparators(0))

    ' Split the string and return all elements
    Console.WriteLine("1a) Return all elements:")
    result = s1.Split(charSeparators, StringSplitOptions.None)
    Show(result)

    ' Split the string and return all elements with whitespace trimmed
    Console.WriteLine("1b) Return all elements with whitespace trimmed:")
    result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string and return all non-empty elements
    Console.WriteLine("1c) Return all non-empty elements:")
    result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string and return all non-whitespace elements with whitespace trimmed
    Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:")
    result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


    ' Split the string into only two elements, keeping the remainder in the last match
    Console.WriteLine("1e) Split into only two elements:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.None)
    Show(result)

    ' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("1f) Split into only two elements with whitespace trimmed:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string into only two non-empty elements, keeping the remainder in the last match
    Console.WriteLine("1g) Split into only two non-empty elements:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


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

    Dim s2 As String = "[stop]" +
                "ONE[stop] [stop]" +
                "TWO  [stop][stop]  [stop]" +
                "THREE[stop][stop]  "
    Dim stringSeparators() As String = {"[stop]"}


    Console.WriteLine("The original string is: ""{0}"".", s2)
    Console.WriteLine("The delimiter string is: ""{0}""." & vbCrLf, stringSeparators(0))

    ' Split the string and return all elements
    Console.WriteLine("2a) Return all elements:")
    result = s2.Split(stringSeparators, StringSplitOptions.None)
    Show(result)

    ' Split the string and return all elements with whitespace trimmed
    Console.WriteLine("2b) Return all elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string and return all non-empty elements
    Console.WriteLine("2c) Return all non-empty elements:")
    result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string and return all non-whitespace elements with whitespace trimmed
    Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


    ' Split the string into only two elements, keeping the remainder in the last match
    Console.WriteLine("2e) Split into only two elements:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
    Show(result)

    ' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("2f) Split into only two elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string into only two non-empty elements, keeping the remainder in the last match
    Console.WriteLine("2g) Split into only two non-empty elements:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    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:
'
' The original string is: ",ONE,, TWO,, , THREE,,".
' The delimiter character is: ','.
'
' 1a) Return all elements:
' The return value contains these 9 elements:
' <><ONE><>< TWO><>< >< THREE><><>
'
' 1b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 1c) Return all non-empty elements:
' The return value contains these 4 elements:
' <ONE>< TWO>< >< THREE>
'
' 1d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 1e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< TWO,, , THREE,,>
'
' 1h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO,, , THREE,,>
'
' 2) Split a string delimited by another string:
'
' The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
' The delimiter string is: "[stop]".
'
' 2a) Return all elements:
' The return value contains these 9 elements:
' <><ONE>< ><TWO  ><><  ><THREE><><  >
'
' 2b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 2c) Return all non-empty elements:
' The return value contains these 6 elements:
' <ONE>< ><TWO  ><  ><THREE><  >
'
' 2d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 2e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >
'
' 2f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>
'
' 2g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >
'
' 2h) Split into only two non-whitespace elements with whitespace trimmed:
' 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 in separatorenthält oder der parameter count 1 ist, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

Um null für den string[] separator-Parameter zu übergeben, müssen Sie den Typ des null angeben, um den Aufruf von einigen anderen Überladungen zu unterscheiden, z. B. Split(Char[], Int32, StringSplitOptions). 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 parameter count null ist oder der parameter optionsRemoveEmptyEntries und die Länge dieser Instanz null ist, wird ein leeres Array zurückgegeben.

Jedes Element von separator definiert ein separates Trennzeichen, das aus einem oder mehreren Zeichen besteht. Wenn der parameter optionsNoneist und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Arrayelement Empty.

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

Das Trennzeichenarray

Wenn eines der Elemente in separator aus mehreren Zeichen besteht, wird die gesamte Teilzeichenfolge als Trennzeichen betrachtet. Wenn z. B. eines der Elemente in separator "10" lautet, wird versucht, die Zeichenfolge "This10is10a10string" aufzuteilen. Gibt dieses Array mit vier Elementen zurück: { "This", "is", "a", "string." }.

Vergleichsdetails

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

Um mehrdeutige Ergebnisse zu vermeiden, wenn Zeichenfolgen in separator Zeichen gemeinsam haben, fährt die Split-Methode vom Anfang bis zum Ende des Werts der Instanz fort und stimmt mit dem ersten Element in 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.

Betrachten Sie beispielsweise eine Instanz, deren Wert "abcdef" lautet. Wenn das erste Element in separator "ef" lautete und das zweite Element "bcde" lautete, wäre das Ergebnis der Unterbrechungsoperation "a" und "f". Dies liegt daran, dass die Teilzeichenfolge in der Instanz "bcde" gefunden wird und mit einem Element in separator übereinstimmt, bevor die Teilzeichenfolge "f" gefunden wird.

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

Leistungsüberlegungen

Hinweise für Aufrufer

Gilt für:

Split(Char[], StringSplitOptions)

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Quelle:: String.Manipulation.cs

Teilt eine Zeichenfolge basierend auf angegebenen Trennzeichen und Optionen in Teilzeichenfolgen auf.

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

Ein Array von Zeichen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array, das keine Trennzeichen enthält, oder null.

options: StringSplitOptions

Eine bitweise Kombination der Enumerationswerte, die angibt, ob Teilzeichenfolgen gekürzt und leere Teilzeichenfolgen eingeschlossen werden sollen.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen in dieser Zeichenfolge enthalten, die durch ein oder mehrere Zeichen in separatorgetrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Attribute: ComVisibleAttribute

Ausnahmen

ArgumentException

options gehört nicht zu den StringSplitOptions Werten.

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.

// Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:\n");

string s1 = ",ONE,, TWO,, , THREE,,";
char[] charSeparators = new char[] { ',' };
string[] result;

Console.WriteLine($"The original string is: \"{s1}\".");
Console.WriteLine($"The delimiter character is: '{charSeparators[0]}'.\n");

// Split the string and return all elements
Console.WriteLine("1a) Return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries);
Show(result);

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

// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);

// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


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

string s2 = "[stop]" +
            "ONE[stop] [stop]" +
            "TWO  [stop][stop]  [stop]" +
            "THREE[stop][stop]  ";
string[] stringSeparators = new string[] { "[stop]" };

Console.WriteLine($"The original string is: \"{s2}\".");
Console.WriteLine($"The delimiter string is: \"{stringSeparators[0]}\".\n");

// Split the string and return all elements
Console.WriteLine("2a) Return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries);
Show(result);

// Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);


// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);

// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
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:

The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.

1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>

1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>

1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>

1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>

2) Split a string delimited by another string:

The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
The delimiter string is: "[stop]".

2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO  ><><  ><THREE><><  >

2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO  ><  ><THREE><  >

2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>

2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2h) Split into only two non-whitespace elements with whitespace trimmed:
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"

// Example 1: Split a string delimited by characters
printfn "1) Split a string delimited by characters:\n"

let s1 = ",ONE,, TWO,, , THREE,,"
let charSeparators = [| ',' |]

printfn $"The original string is: \"{s1}\"."
printfn $"The delimiter character is: '{charSeparators[0]}'.\n"

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

// Split the string and return all elements with whitespace trimmed
printfn "1b) Return all elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
show result

// Split the string and return all non-empty elements
printfn "1c) Return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "1d) Return all non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


// Split the string into only two elements, keeping the remainder in the last match
printfn "1e) Split into only two elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.None)
show result

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "1f) Split into only two elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
show result

// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "1g) Split into only two non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "1h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


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

let s2 = "[stop]" +
            "ONE[stop] [stop]" +
            "TWO  [stop][stop]  [stop]" +
            "THREE[stop][stop]  "
let stringSeparators = [| "[stop]" |]

printfn $"The original string is: \"{s2}\"."
printfn $"The delimiter string is: \"{stringSeparators[0]}\".\n"

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

// Split the string and return all elements with whitespace trimmed
printfn "2b) Return all elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
show result

// Split the string and return all non-empty elements
printfn "2c) Return all non-empty elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "2d) Return all non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result


// Split the string into only two elements, keeping the remainder in the last match
printfn "2e) Split into only two elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
show result

// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "2f) Split into only two elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
show result

// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "2g) Split into only two non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result

// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "2h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result

(*
This example produces the following results:

1) Split a string delimited by characters:

The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.

1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>

1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>

1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>

1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>

1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>

2) Split a string delimited by another string:

The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
The delimiter string is: "[stop]".

2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO  ><><  ><THREE><><  >

2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO  ><  ><THREE><  >

2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>

2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >

2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO  [stop][stop]  [stop]THREE[stop][stop]>

*)

Public Shared Sub StringSplitOptionsExamples()
    ' This example demonstrates the String.Split() methods that use
    ' the StringSplitOptions enumeration.

    ' Example 1: Split a string delimited by characters
    Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)

    Dim s1 As String = ",ONE,, TWO,, , THREE,,"
    Dim charSeparators() As Char = {","c}
    Dim result() As String

    Console.WriteLine("The original string is: ""{0}"".", s1)
    Console.WriteLine("The delimiter character is: '{0}'." & vbCrLf, charSeparators(0))

    ' Split the string and return all elements
    Console.WriteLine("1a) Return all elements:")
    result = s1.Split(charSeparators, StringSplitOptions.None)
    Show(result)

    ' Split the string and return all elements with whitespace trimmed
    Console.WriteLine("1b) Return all elements with whitespace trimmed:")
    result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string and return all non-empty elements
    Console.WriteLine("1c) Return all non-empty elements:")
    result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string and return all non-whitespace elements with whitespace trimmed
    Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:")
    result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


    ' Split the string into only two elements, keeping the remainder in the last match
    Console.WriteLine("1e) Split into only two elements:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.None)
    Show(result)

    ' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("1f) Split into only two elements with whitespace trimmed:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string into only two non-empty elements, keeping the remainder in the last match
    Console.WriteLine("1g) Split into only two non-empty elements:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:")
    result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


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

    Dim s2 As String = "[stop]" +
                "ONE[stop] [stop]" +
                "TWO  [stop][stop]  [stop]" +
                "THREE[stop][stop]  "
    Dim stringSeparators() As String = {"[stop]"}


    Console.WriteLine("The original string is: ""{0}"".", s2)
    Console.WriteLine("The delimiter string is: ""{0}""." & vbCrLf, stringSeparators(0))

    ' Split the string and return all elements
    Console.WriteLine("2a) Return all elements:")
    result = s2.Split(stringSeparators, StringSplitOptions.None)
    Show(result)

    ' Split the string and return all elements with whitespace trimmed
    Console.WriteLine("2b) Return all elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string and return all non-empty elements
    Console.WriteLine("2c) Return all non-empty elements:")
    result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string and return all non-whitespace elements with whitespace trimmed
    Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    Show(result)


    ' Split the string into only two elements, keeping the remainder in the last match
    Console.WriteLine("2e) Split into only two elements:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
    Show(result)

    ' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("2f) Split into only two elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
    Show(result)

    ' Split the string into only two non-empty elements, keeping the remainder in the last match
    Console.WriteLine("2g) Split into only two non-empty elements:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
    Show(result)

    ' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
    Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:")
    result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
    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:
'
' The original string is: ",ONE,, TWO,, , THREE,,".
' The delimiter character is: ','.
'
' 1a) Return all elements:
' The return value contains these 9 elements:
' <><ONE><>< TWO><>< >< THREE><><>
'
' 1b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 1c) Return all non-empty elements:
' The return value contains these 4 elements:
' <ONE>< TWO>< >< THREE>
'
' 1d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 1e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< TWO,, , THREE,,>
'
' 1h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO,, , THREE,,>
'
' 2) Split a string delimited by another string:
'
' The original string is: "[stop]ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  ".
' The delimiter string is: "[stop]".
'
' 2a) Return all elements:
' The return value contains these 9 elements:
' <><ONE>< ><TWO  ><><  ><THREE><><  >
'
' 2b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 2c) Return all non-empty elements:
' The return value contains these 6 elements:
' <ONE>< ><TWO  ><  ><THREE><  >
'
' 2d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 2e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >
'
' 2f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]>
'
' 2g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< [stop]TWO  [stop][stop]  [stop]THREE[stop][stop]  >
'
' 2h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO  [stop][stop]  [stop]THREE[stop][stop]>
'

Hinweise

Trennzeichen (die Zeichen im separator Array) sind nicht in den Elementen des zurückgegebenen Arrays enthalten. Wenn das separator Array beispielsweise 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 keines der Zeichen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.

Wenn der parameter optionsRemoveEmptyEntries und die Länge dieser Instanz null ist, gibt die Methode ein leeres Array zurück.

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

String.Empty, die die leere Zeichenfolge darstellt, die dem Zeichen "-" bei Index 0 vorangestellt ist.
String.Empty, die die leere Zeichenfolge zwischen dem Zeichen "-" bei Index 0 und dem Zeichen "_" bei Index 1 darstellt.
"aa".
String.Empty, die die leere Zeichenfolge darstellt, die dem Zeichen "-" bei Index 4 folgt.
String.Empty, die die leere Zeichenfolge darstellt, die dem Zeichen "_" bei Index 5 folgt.

Das Trennzeichenarray

Um null für den char[] separator-Parameter zu übergeben, müssen Sie den Typ des null angeben, um den Aufruf von einigen anderen Überladungen zu unterscheiden, z. B. Split(String[], StringSplitOptions). Das folgende Beispiel zeigt mehrere Möglichkeiten, um 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 Teilzeichenfolgen in dieser Zeichenfolge, die durch ein oder mehrere Zeichen im separator-Parameter getrennt sind, und gibt diese Teilzeichenfolgen als Elemente eines Arrays zurück.

Leistungsüberlegungen

Hinweise für Aufrufer

Gilt für:

Teilen über

String.Split Methode

Definition

Überlädt

Hinweise

Beispiel

Split(String, Int32, StringSplitOptions)

Parameter

Gibt zurück

Hinweise

Gilt für:

Split(Char[], Int32, StringSplitOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Leistungsüberlegungen

Hinweise für Aufrufer

Gilt für:

Split(Char, Int32, StringSplitOptions)

Parameter

Gibt zurück

Hinweise

Gilt für:

Split(String[], StringSplitOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Das Trennzeichenarray

Vergleichsdetails

Leistungsüberlegungen

Hinweise für Aufrufer

Gilt für:

Split(String, StringSplitOptions)

Parameter

Gibt zurück

Gilt für:

Split(Char[])

Parameter

Gibt zurück

Beispiele

Hinweise

Das Trennzeichenarray

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

Vergleichsdetails

Leistungsüberlegungen

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Split(Char[], Int32)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Leistungsüberlegungen

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Split(Char, StringSplitOptions)

Parameter

Gibt zurück

Gilt für:

Split(ReadOnlySpan<Char>)

Parameter

Gibt zurück

Gilt für:

Split(String[], Int32, StringSplitOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Das Trennzeichenarray

Vergleichsdetails

Leistungsüberlegungen

Hinweise für Aufrufer