String.Split Methode

Definition

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

Überlädt

Split(Char[])

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

Split(Char, StringSplitOptions)

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

Split(Char[], Int32)

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

Split(Char[], StringSplitOptions)

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

Split(String, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in Teilzeichenfolgen.

Split(String[], StringSplitOptions)

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

Split(Char, Int32, StringSplitOptions)

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

Split(Char[], Int32, StringSplitOptions)

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

Split(String, Int32, StringSplitOptions)

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

Split(String[], Int32, StringSplitOptions)

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

Hinweise

Split wird verwendet, um eine durch Trennzeichen getrennte Zeichenfolge in Teilzeichenfolgen zu unterteilen. Sie können entweder ein Zeichenarray oder ein Zeichenfolgenarray verwenden, um null oder mehr Trennzeichen oder Zeichenfolgen anzugeben. Wenn keine Trennzeichen angegeben sind, wird die Zeichenfolge in Leerzeichen aufgeteilt.

Mit Überladungen der Split -Methode können Sie die Anzahl der von der -Methode (der Split(Char[], Int32) -Methode) zurückgegebenen Teilzeichenfolgen begrenzen, um anzugeben, ob leere Zeichenfolgen und/oder Teilzeichenfolgen in das Ergebnis (die Split(Char[], StringSplitOptions) Methoden und Split(String[], StringSplitOptions) ) eingeschlossen werden sollen oder ob beides (die Split(Char[], Int32, StringSplitOptions) Methoden und Split(String[], Int32, StringSplitOptions) ) erfolgen soll.

Tipp

Die Split -Methode ist nicht immer die beste Möglichkeit, eine durch Trennzeichen getrennte Zeichenfolge in Teilzeichenfolgen zu unterteilen. Wenn Sie nicht alle Teilzeichenfolgen einer durch Trennzeichen getrennten Zeichenfolge extrahieren möchten, oder wenn Sie eine Zeichenfolge basierend auf einem Muster anstelle eines Satzes von Trennzeichen analysieren möchten, sollten Sie die Verwendung regulärer Ausdrücke in Betracht ziehen oder eine der Suchmethoden kombinieren, die den Index eines Zeichens mit der Substring -Methode zurückgibt. 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. Im nächsten Beispiel wird gezeigt, wie dies geschieht.

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

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

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

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:
let s = "You win some. You lose some."

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

for sub in subs do
    printfn $"Substring: {sub}"

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

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

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

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

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

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

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

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some
let s = "You win some. You lose some."
let separators = [| ' '; '.' |]

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

for sub in subs do
    printfn $"Substring: {sub}"

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

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

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

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

Split(Char[])

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

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

Parameter

separator
Char[]

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

Gibt zurück

String[]

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

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie einzelne Wörter aus einem Textblock extrahiert werden, indem das Leerzeichen ( ) und das Tabstoppzeichen (\t) als Trennzeichen behandelt werden. Die zu teilende 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 unterteilen.

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

Wenn dieses instance keines der Zeichen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese instance enthält.

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

Die folgende Tabelle enthält einige Beispiele.

Sprache Zeichenfolgenwert Trennzeichen Zurückgegebenes Array
C# "42, 12, 19" new Char[] {',', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char() = {","c, " "c}) {"42", "", "12", "", "19"}
C# "42..12..19." 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" new 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 separator Argument keine Zeichen enthält oder ist null , behandelt die Methode Leerzeichen als Trennzeichen. Leerzeichen werden durch den Unicode-Standard definiert, und die Char.IsWhiteSpace Methode gibt zurück true , wenn ein Leerzeichen an sie ü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 ParamArrayAttribute -Attribut versehen ist, interpretieren Compiler ein einzelnes Zeichen als Ein-Element-Zeichenarray. Dies gilt nicht für andere String.Split Überladungen, die einen separator Parameter enthalten. Sie müssen diese Überladungen explizit ein Zeichenarray als separator Argument ü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 unter Verwendung von Ordnungssortierungsregeln durchgeführt werden, bei der die Groß-/Kleinschreibung beachtet wird. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierungen finden Sie in der System.Globalization.CompareOptions -Enumeration.

Überlegungen zur Leistung

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

Um eine Zeichenfolge an einem Trennzeichen aufzuteilen, verwenden Sie die IndexOf - oder IndexOfAny -Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Um eine Zeichenfolge an einer Trennzeichenfolge aufzuteilen, 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 dem 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 darüber hinaus erwägen, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen. Dadurch wird der zusätzliche Mehraufwand für jeden Methodenaufruf erheblich reduziert.

Hinweise für Aufrufer

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

Weitere Informationen

Gilt für:

Split(Char, StringSplitOptions)

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

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

Parameter

separator
Char

Ein Zeichen, das die Teilzeichenfolgen in dieser Zeichenfolge trennt.

options
StringSplitOptions

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

Gibt zurück

String[]

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

Gilt für:

Split(Char[], Int32)

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

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

Parameter

separator
Char[]

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

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

Gibt zurück

String[]

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

Ausnahmen

count ist ein negativer Wert.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie count die Anzahl der von Splitzurückgegebenen Zeichenfolgen begrenzt werden kann.

string name = "Alex Johnson III";

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

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

// firstName = "Alex"
// lastName = "Johnson III"
let name = "Alex Johnson III"

let subs = name.Split(null, 2)

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

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

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

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

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

Hinweise

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

Wenn dieses instance keines der Zeichen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese instance enthält. Wenn count null ist, wird ein leeres Array zurückgegeben.

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

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

Wenn in diesem instance 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 verbleibenden Zeichen in diesem instance 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.

Die folgende Tabelle enthält einige Beispiele.

Sprache Zeichenfolgenwert Trennzeichen Zurückgegebenes Array
C# "42, 12, 19" new Char[] {',', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char() = {","c, " "c}) {"42", "", "12", "", "19"}
C# "42..12..19." 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" new Char[] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char() = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" NULL {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nichts {"Darb", "Smarba"}

Überlegungen zur Leistung

Die Split Methoden weisen Arbeitsspeicher 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 Speicherbelegung in Ihrer Anwendung wichtig ist, sollten Sie die IndexOf - oder IndexOfAny -Methode und optional die Compare -Methode verwenden, um eine Teilzeichenfolge innerhalb einer Zeichenfolge zu finden.

Wenn Sie eine Zeichenfolge an einem Trennzeichen aufteilen, verwenden Sie die IndexOf - oder IndexOfAny -Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge an einer Trennzeichenfolge aufteilen, 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 dem 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 darüber hinaus erwägen, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen. Dadurch wird der zusätzliche Mehraufwand für jeden Methodenaufruf erheblich reduziert.

Hinweise für Aufrufer

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

Weitere Informationen

Gilt für:

Split(Char[], StringSplitOptions)

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

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

Parameter

separator
Char[]

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

options
StringSplitOptions

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

Gibt zurück

String[]

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

Attribute

Ausnahmen

options entspricht keinem der StringSplitOptions-Werte.

Beispiele

Im folgenden Beispiel wird die StringSplitOptions -Enumeration verwendet, um von der Split -Methode generierte Teilzeichenfolgen einzu- oder auszuschließen.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

End Sub


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

End Sub

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

Hinweise

Trennzeichen (die Zeichen im 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 Zeichenfolge instance "aa-bb-cc" ist, gibt die Methode ein Array zurück, das drei Elemente enthält: "aa", "bb" und "cc".

Wenn dieses instance keines der Zeichen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese instance enthält.

Wenn der options Parameter ist RemoveEmptyEntries und die Länge dieses instance 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 options Argument ist Noneund zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieses instance gefunden wird, enthält String.Emptydas entsprechende Arrayelement . Wenn separator z. B. zwei Elemente und '_'enthält, '-' lautet der Wert der Zeichenfolge instance "-_aa-_", und der Wert des options Arguments ist None, gibt die Methode ein Zeichenfolgenarray mit den folgenden fünf Elementen zurück:

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

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

  3. "aa".

  4. String.Empty, die die leere Zeichenfolge darstellt, die auf das Zeichen "-" am Index 4 folgt.

  5. String.Empty, die die leere Zeichenfolge darstellt, die auf das Zeichen "_" bei Index 5 folgt.

Das Trennzeichenarray

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

Um für den char[] separator -Parameter zu übergebennull, müssen Sie den Typ von null angeben, um den Aufruf von einigen anderen Überladungen zu unterscheiden, zSplit(String[], StringSplitOptions). B. . Das folgende Beispiel zeigt mehrere Möglichkeiten, 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.

Die Split -Methode sucht nach Trennzeichen, indem Vergleiche unter Verwendung von Ordnungssortierungsregeln durchgeführt werden, bei der die Groß-/Kleinschreibung beachtet wird. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierungen finden Sie in der System.Globalization.CompareOptions -Enumeration.

Überlegungen zur Leistung

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

Wenn Sie eine Zeichenfolge an einem Trennzeichen aufteilen, verwenden Sie die IndexOf - oder IndexOfAny -Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge an einer Trennzeichenfolge aufteilen, 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 dem 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 darüber hinaus erwägen, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen. Dadurch wird der zusätzliche Mehraufwand für jeden Methodenaufruf erheblich reduziert.

Hinweise für Aufrufer

Wenn in .NET Framework 3.5 und früheren Versionen die Split(Char[]) -Methode ein separator übergeben wird, das null keine Zeichen enthält oder enthält, verwendet die Methode einen etwas anderen Satz von Leerzeichen, 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(String, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in Teilzeichenfolgen.

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

Parameter

separator
String

Eine Zeichenfolge, die die Teilzeichenfolgen in dieser Zeichenfolge trennt.

options
StringSplitOptions

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

Gibt zurück

String[]

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

Gilt für:

Split(String[], StringSplitOptions)

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

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

Parameter

separator
String[]

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

options
StringSplitOptions

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

Gibt zurück

String[]

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

Attribute

Ausnahmen

options entspricht keinem der StringSplitOptions-Werte.

Beispiele

Das folgende Beispiel veranschaulicht den Unterschied in den Arrays, die durch Aufrufen der -Methode einer Zeichenfolge String.Split(String[], StringSplitOptions) mit ihrem options Parameter gleich 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. Das Übergeben dieses Arrays zusammen mit dem Wert von StringSplitOptions.RemoveEmptyEntries an die Split(String[], StringSplitOptions) -Methode gibt ein Array zurück, 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 options Argument auf StringSplitOptions.RemoveEmptyEntriesfestgelegt ist. Dadurch wird verhindert, dass das zurückgegebene Array Werte einschließt String.Empty , die leere Teilzeichenfolgenübereinstimmungen 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 unterteilen.

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 Zeichenfolge instance "aa--bb--cc" ist, gibt die Methode ein Array zurück, das drei Elemente enthält: "aa", "bb" und "cc".

Wenn dieser instance keine der Zeichenfolgen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese instance enthält.

Wenn der options Parameter ist RemoveEmptyEntries und die Länge dieses instance 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 options Argument ist Noneund zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieses instance gefunden wird, enthält String.Emptydas entsprechende Arrayelement . Wenn separator z. B. zwei Elemente enthält, "-" und "_", ist der Wert der Zeichenfolge instance "-_aa-_", und der Wert des options Arguments ist None, gibt die Methode ein Zeichenfolgenarray mit den folgenden fünf Elementen zurück:

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

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

  3. "aa".

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

  5. String.Empty, die die leere Zeichenfolge darstellt, die der 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" ist, gibt der Versuch, die Zeichenfolge "This10is10a10string." aufzuteilen, das folgende Array mit vier Elementen zurück: { "This", "is", "a", "string." }.

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

Um für den string[] separator -Parameter zu übergebennull, müssen Sie den Typ von null angeben, um den Aufruf von einigen anderen Überladungen zu unterscheiden, zSplit(Char[], StringSplitOptions). B. . Das folgende Beispiel zeigt mehrere Möglichkeiten, 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 Zeichenfolgen im separator Parameter getrennt sind, und gibt diese Teilzeichenfolgen als Elemente eines Arrays zurück.

Die Split -Methode sucht nach Trennzeichen, indem Vergleiche unter Verwendung von Ordnungssortierungsregeln durchgeführt werden, bei der die Groß-/Kleinschreibung beachtet wird. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierungen finden Sie in der System.Globalization.CompareOptions -Enumeration.

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

Um mehrdeutige Ergebnisse zu vermeiden, wenn Zeichenfolgen in separator Zeichen gemeinsam haben, wird der Split Vorgang vom Anfang bis zum Ende des Werts des instance fortgesetzt und entspricht dem ersten Element inseparator, das einem Trennzeichen im instance entspricht. Die Reihenfolge, in der Teilzeichenfolgen im instance gefunden werden, hat Vorrang vor der Reihenfolge der Elemente in separator.

Betrachten Sie beispielsweise eine instance deren Wert "abcdef" ist. Wenn das erste Element in separator "ef" und das zweite Element "bcde" lautete, wäre das Ergebnis des Teilungsvorgangs ein Zeichenfolgenarray, das zwei Elemente enthält, "a" und "f". Dies liegt daran, dass die Teilzeichenfolge im instance "bcde" gefunden wird und einem Element in separator entspricht, bevor die Teilzeichenfolge "f" gefunden wird.

Wenn das erste Element von separator jedoch "bcd" und das zweite Element "bc" lautet, wäre das Ergebnis des Split-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 im instance entspricht. Wenn die Reihenfolge der Trennzeichen umgekehrt wurde, sodass das erste Element "bc" und das zweite Element "bcd" lautete, wäre das Ergebnis ein Zeichenfolgenarray, das zwei Elemente enthält: "a" und "def".

Überlegungen zur Leistung

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

Wenn Sie eine Zeichenfolge an einem Trennzeichen aufteilen, verwenden Sie die IndexOf - oder IndexOfAny -Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge an einer Trennzeichenfolge aufteilen, 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 dem 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 darüber hinaus erwägen, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen. Dadurch wird der zusätzliche Mehraufwand für jeden Methodenaufruf erheblich reduziert.

Hinweise für Aufrufer

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

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

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

Parameter

separator
Char

Ein Zeichen, das die Teilzeichenfolgen in dieser Instanz trennt.

count
Int32

Die maximale Anzahl der im Array erwarteten Elemente.

options
StringSplitOptions

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

Gibt zurück

String[]

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

Hinweise

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

Gilt für:

Split(Char[], Int32, StringSplitOptions)

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

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

Parameter

separator
Char[]

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

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

options
StringSplitOptions

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

Gibt zurück

String[]

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

Attribute

Ausnahmen

count ist ein negativer Wert.

options entspricht keinem der StringSplitOptions-Werte.

Beispiele

Im folgenden Beispiel wird die StringSplitOptions -Enumeration verwendet, um von der Split -Methode generierte Teilzeichenfolgen einzu- oder auszuschließen.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

End Sub


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

End Sub

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

Hinweise

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

Wenn dieses instance keines der Zeichen in separatorenthält oder der count Parameter 1 ist, besteht das zurückgegebene Array aus einem einzelnen Element, das diese instance enthält.

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

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

string phrase = "The quick  brown fox";

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

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

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

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

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

phrase.Split((null: char[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

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

Jedes Element von separator definiert ein separates Trennzeichen. Wenn der options Parameter ist Noneund zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieses instance gefunden wird, enthält Emptydas entsprechende Arrayelement .

Wenn in diesem instance mehr als count Teilzeichenfolgen vorhanden sind, werden die ersten count minus 1 Teilzeichenfolgen in den ersten count minus 1 Elementen des Rückgabewerts zurückgegeben, und die verbleibenden Zeichen in diesem instance 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.

Überlegungen zur Leistung

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

Wenn Sie eine Zeichenfolge an einem Trennzeichen aufteilen, verwenden Sie die IndexOf - oder IndexOfAny -Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge an einer Trennzeichenfolge aufteilen, 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 dem 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 darüber hinaus erwägen, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen. Dadurch wird der zusätzliche Mehraufwand für jeden Methodenaufruf erheblich reduziert.

Hinweise für Aufrufer

Wenn in .NET Framework 3.5 und früheren Versionen die Split(Char[]) -Methode ein separator übergeben wird, das null keine Zeichen enthält oder enthält, verwendet die Methode einen etwas anderen Satz von Leerzeichen, 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(String, Int32, StringSplitOptions)

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

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

Parameter

separator
String

Eine Zeichenfolge, die die Teilzeichenfolgen in dieser Instanz trennt.

count
Int32

Die maximale Anzahl der im Array erwarteten Elemente.

options
StringSplitOptions

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

Gibt zurück

String[]

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

Hinweise

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

Gilt für:

Split(String[], Int32, StringSplitOptions)

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

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

Parameter

separator
String[]

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

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.

options
StringSplitOptions

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

Gibt zurück

String[]

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

Attribute

Ausnahmen

count ist ein negativer Wert.

options entspricht keinem der StringSplitOptions-Werte.

Beispiele

Im folgenden Beispiel wird die StringSplitOptions -Enumeration verwendet, um von der Split -Methode generierte Teilzeichenfolgen einzu- oder auszuschließen.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

End Sub


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

End Sub

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

Hinweise

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

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

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

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

string phrase = "The quick  brown fox";

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

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

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

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

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

phrase.Split((null: string[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

Wenn der count Parameter null oder der options Parameter ist RemoveEmptyEntries und die Länge dieses instance 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 options Parameter ist Noneund zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieses instance gefunden wird, enthält Emptydas entsprechende Arrayelement .

Wenn in diesem instance mehr als count Teilzeichenfolgen vorhanden sind, werden die ersten count minus 1 Teilzeichenfolgen in den ersten count minus 1 Elementen des Rückgabewerts zurückgegeben, und die verbleibenden Zeichen in diesem instance 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.

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" ist, gibt der Versuch, die Zeichenfolge "This10is10a10string." aufzuteilen, dieses Array mit vier Elementen zurück: { "This", "is", "a", "string." }.

Vergleichsdetails

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

Die Split -Methode sucht nach Trennzeichen, indem Vergleiche unter Verwendung von Ordnungssortierungsregeln durchgeführt werden, bei der die Groß-/Kleinschreibung beachtet wird. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierungen finden Sie in der System.Globalization.CompareOptions -Enumeration.

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

Um mehrdeutige Ergebnisse zu vermeiden, wenn Zeichenfolgen in separator Zeichen gemeinsam haben, fährt die Split Methode vom Anfang bis zum Ende des Werts des instance und gleicht dem ersten Element inseparator, das einem Trennzeichen im instance entspricht. Die Reihenfolge, in der Teilzeichenfolgen im instance gefunden werden, hat Vorrang vor der Reihenfolge der Elemente in separator.

Betrachten Sie beispielsweise eine instance deren Wert "abcdef" ist. Wenn das erste Element in separator "ef" und das zweite Element "bcde" lautete, lautete das Ergebnis des Aufteilungsvorgangs "a" und "f". Dies liegt daran, dass die Teilzeichenfolge im instance "bcde" gefunden wird und einem Element in separator entspricht, bevor die Teilzeichenfolge "f" gefunden wird.

Wenn jedoch das erste Element von separator "bcd" und das zweite Element "bc" lautete, würde das Ergebnis des Splitvorgangs "a" und "ef" sein. Dies liegt daran, dass "bcd" das erste Trennzeichen in separator ist, das einem Trennzeichen im instance entspricht. Wenn die Reihenfolge der Trennzeichen umgekehrt wurde, sodass das erste Element "bc" und das zweite Element "bcd" lautete, lautete das Ergebnis "a" und "def".

Überlegungen zur Leistung

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

Wenn Sie eine Zeichenfolge an einem Trennzeichen aufteilen, verwenden Sie die IndexOf - oder IndexOfAny -Methode, um ein Trennzeichen in der Zeichenfolge zu suchen. Wenn Sie eine Zeichenfolge an einer Trennzeichenfolge aufteilen, 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 dem 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 darüber hinaus erwägen, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen. Dadurch wird der zusätzliche Mehraufwand für jeden Methodenaufruf erheblich reduziert.

Hinweise für Aufrufer

Wenn in .NET Framework 3.5 und früheren Versionen die Split(Char[]) -Methode ein separator übergeben wird, das null keine Zeichen enthält oder enthält, verwendet die Methode einen etwas anderen Satz von Leerzeichen, 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: