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.Returns a string array that contains the substrings in this instance that are delimited by elements of a specified string or Unicode character array.

Überlädt

Split(Char[], Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char, Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichentrennlinie in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number substrings based on the provided character separator.

Split(String[], Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number of substrings based on the strings in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in Teilzeichenfolgen.Splits a string into substrings based on the strings in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number of substrings based on the provided string separator.

Split(Char[], StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen.Splits a string into substrings based on the characters in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.You can specify whether the substrings include empty array elements.

Split(Char[], Int32)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number of substrings based on the characters in an array. Sie geben außerdem die maximale Anzahl der zurückzugebenden Teilzeichenfolgen an.You also specify the maximum number of substrings to return.

Split(Char, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichentrennlinie in Teilzeichenfolgen.Splits a string into substrings based on the provided character separator.

Split(String, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in Teilzeichenfolgen.Splits a string into substrings that are based on the provided string separator.

Split(Char[])

Unterteilt eine Zeichenfolge anhand der Zeichen im Trennlinienarray in Teilzeichenfolgen.Splits a string into substrings that are based on the characters in the separator array.

Hinweise

Split wird verwendet, um eine Zeichenfolge mit Trennzeichen in Teil Zeichenfolgen zu zerlegen.Split is used to break a delimited string into substrings. Sie können entweder ein Zeichen Array verwenden, um 0 (null), ein Zeichen oder mehrere Trennzeichen (die Split(Char[])-Methode) anzugeben, oder Sie können ein Zeichen Array verwenden, um NULL, eine Zeichenfolge oder mehrere Begrenzungs Zeichenfolgen anzugeben.You can use either a character array to specify zero, one, or multiple delimiting characters (the Split(Char[]) method), or you can use a character array to specify zero, one, or multiple delimiting strings. Über Ladungen der Split-Methode ermöglichen es Ihnen, die Anzahl der von der-Methode zurückgegebenen Teil Zeichenfolgen einzuschränken (die Split(Char[], Int32)-Methode), um zu bestimmen, ob leere Zeichen folgen in die zurückgegebenen Teil Zeichenfolgen (die Split(Char[], StringSplitOptions)-und Split(String[], StringSplitOptions)-Methoden oder beides (die Split(Char[], Int32, StringSplitOptions)-und Split(String[], Int32, StringSplitOptions)-Methoden) eingeschlossen werden.Overloads of the Split method allow you to limit the number of substrings returned by the method (the Split(Char[], Int32) method), to determine whether empty strings are included in the returned substrings (the Split(Char[], StringSplitOptions) and Split(String[], StringSplitOptions) methods, or to do both (the Split(Char[], Int32, StringSplitOptions) and Split(String[], Int32, StringSplitOptions) methods).

Hinweis

Die C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.The C# examples in this article run in the Try.NET inline code runner and playground. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen.Select the Run button to run an example in an interactive window. Nachdem Sie den Code ausgeführt haben, können Sie ihn ändern und den geänderten Code durch erneutes Anklicken der Schaltfläche Ausführen ausführen.Once you execute the code, you can modify it and run the modified code by selecting Run again. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder das interaktive Fenster zeigt alle C#-Compilerfehlermeldungen an, wenn die Kompilierung fehlschlägt.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Alternativen zu String. SplitAlternatives to String.Split

Die Split-Methode ist nicht immer die beste Möglichkeit, eine durch Trennzeichen getrennte Zeichenfolge in Teil Zeichenfolgen zu unterteilen.The Split method is not always the best way to break a delimited string into substrings. Wenn Sie nicht alle Teil Zeichenfolgen einer durch Trennzeichen getrennten Zeichenfolge extrahieren möchten oder wenn Sie eine Zeichenfolge auf Grundlage eines Musters anstelle eines Satzes von Trennzeichen analysieren möchten, sollten Sie die folgenden Alternativen in Erwägung ziehen.If you don't want to extract all of the substrings of a delimited string, or if you want to parse a string based on a pattern instead of a set of delimiter characters, consider the following alternatives.

Reguläre AusdrückeRegular expressions

Wenn die Zeichen folgen einem festen Muster entsprechen, können Sie einen regulären Ausdruck verwenden, um ihre Elemente zu extrahieren und zu verarbeiten.If your strings conform to a fixed pattern, you can use a regular expression to extract and handle their elements. Wenn Zeichen folgen z. b. die Form "Number Operand Number" haben, können Sie einen regulären Ausdruck verwenden, um die Elemente der Zeichenfolge zu extrahieren und zu verarbeiten.For example, if strings take the form "number operand number" you can use a regular expression to extract and handle the string's elements. Im Folgenden ein Beispiel:Here's an example:

   String[] expressions = { "16 + 21", "31 * 3", "28 / 3",
                            "42 - 18", "12 * 7",
                            "2, 4, 6, 8" };
   String pattern = @"(\d+)\s+([-+*/])\s+(\d+)";
   foreach (var expression in expressions)
      foreach (System.Text.RegularExpressions.Match m in 
      System.Text.RegularExpressions.Regex.Matches(expression, pattern)) {
         int value1 = Int32.Parse(m.Groups[1].Value);
         int value2 = Int32.Parse(m.Groups[3].Value);
         switch (m.Groups[2].Value)
         {
            case "+":
               Console.WriteLine("{0} = {1}", m.Value, value1 + value2);
               break;
            case "-":
               Console.WriteLine("{0} = {1}", m.Value, value1 - value2);
               break;
            case "*":
               Console.WriteLine("{0} = {1}", m.Value, value1 * value2);
               break;
            case "/":
               Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2);
               break;
         }
      }
// The example displays the following output:
//       16 + 21 = 37
//       31 * 3 = 93
//       28 / 3 = 9.33
//       42 - 18 = 24
//       12 * 7 = 84
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim expressions() As String = { "16 + 21", "31 * 3", "28 / 3",
                                      "42 - 18", "12 * 7",
                                      "2, 4, 6, 8" }

      Dim pattern As String = "(\d+)\s+([-+*/])\s+(\d+)"
      For Each expression In expressions
         For Each m As Match in Regex.Matches(expression, pattern)
            Dim value1 As Integer = Int32.Parse(m.Groups(1).Value)
            Dim value2 As Integer = Int32.Parse(m.Groups(3).Value)
            Select Case m.Groups(2).Value
               Case "+"
                  Console.WriteLine("{0} = {1}", m.Value, value1 + value2)
               Case "-"
                  Console.WriteLine("{0} = {1}", m.Value, value1 - value2)
               Case "*"
                  Console.WriteLine("{0} = {1}", m.Value, value1 * value2)
               Case "/"
                  Console.WriteLine("{0} = {1:N2}", m.Value, value1 / value2)
            End Select
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       16 + 21 = 37
'       31 * 3 = 93
'       28 / 3 = 9.33
'       42 - 18 = 24
'       12 * 7 = 84

Das Muster für reguläre Ausdrücke (\d+)\s+([-+*/])\s+(\d+) wie folgt definiert:The regular expression pattern (\d+)\s+([-+*/])\s+(\d+) is defined like this:

MusterPattern BeschreibungDescription
(\d+) Entsprechung für mindestens eine Dezimalstelle finden.Match one or more decimal digits. Dies ist die erste Erfassungsgruppe.This is the first capturing group.
\s+ Entspricht einem oder mehreren Leerzeichen.Match one or more white-space characters.
([-+*/]) Entsprechung für ein arithmetisches Operator Zeichen (+,-, * oder/).Match an arithmetic operator sign (+, -, *, or /). Dies ist die zweite Erfassungsgruppe.This is the second capturing group.
\s+ Entspricht einem oder mehreren Leerzeichen.Match one or more white-space characters.
(\d+) Entsprechung für mindestens eine Dezimalstelle finden.Match one or more decimal digits. Dies ist die dritte Erfassungsgruppe.This is the third capturing group.

Sie können auch einen regulären Ausdruck verwenden, um Teil Zeichenfolgen auf der Grundlage eines Musters anstelle eines festen Zeichensatzes aus einer Zeichenfolge zu extrahieren.You can also use a regular expression to extract substrings from a string based on a pattern rather than a fixed set of characters. Dies ist ein häufiges Szenario, wenn eine der folgenden Bedingungen zutrifft:This is a common scenario when either of these conditions occurs:

  • Mindestens eines der Trennzeichen dient nicht immer als Trennzeichen in der String Instanz.One or more of the delimiter characters does not always serve as a delimiter in the String instance.

  • Die Sequenz und die Anzahl der Trennzeichen sind variabel oder unbekannt.The sequence and number of delimiter characters is variable or unknown.

Beispielsweise kann die Split-Methode nicht zum Aufteilen der folgenden Zeichenfolge verwendet werden, da die Anzahl der \n C#(in) oder vbCrLf (in Visual Basic)-Zeichen variabel ist und nicht immer als Trennzeichen dienen.For example, the Split method cannot be used to split the following string, because the number of \n (in C#) or vbCrLf (in Visual Basic) characters is variable, and they don't always serve as delimiters.

[This is captured\ntext.]\n\n[\n[This is more captured text.]\n]  
\n[Some more captured text:\n   Option1\n   Option2][Terse text.]  

Ein regulärer Ausdruck kann diese Zeichenfolge leicht aufteilen, wie im folgenden Beispiel gezeigt.A regular expression can split this string easily, as the following example shows.

String input = "[This is captured\ntext.]\n\n[\n" +
               "[This is more captured text.]\n]\n" +
               "[Some more captured text:\n   Option1" +
               "\n   Option2][Terse text.]";
String pattern = @"\[([^\[\]]+)\]";
int ctr = 0;
foreach (System.Text.RegularExpressions.Match m in 
   System.Text.RegularExpressions.Regex.Matches(input, pattern))
   Console.WriteLine("{0}: {1}", ++ctr, m.Groups[1].Value);
// The example displays the following output:
//       1: This is captured
//       text.
//       2: This is more captured text.
//       3: Some more captured text:
//          Option1
//          Option2
//       4: Terse text.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = String.Format("[This is captured{0}text.]" +
                                          "{0}{0}[{0}[This is more " +
                                          "captured text.]{0}{0}" +
                                          "[Some more captured text:" +
                                          "{0}   Option1" +
                                          "{0}   Option2][Terse text.]",
                                          vbCrLf)
      Dim pattern As String = "\[([^\[\]]+)\]"
      Dim ctr As Integer = 0
      For Each m As Match In Regex.Matches(input, pattern)
         ctr += 1
         Console.WriteLine("{0}: {1}", ctr, m.Groups(1).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       1: This is captured
'       text.
'       2: This is more captured text.
'       3: Some more captured text:
'          Option1
'          Option2
'       4: Terse text.

Das Muster für reguläre Ausdrücke \[([^\[\]]+)\] wie folgt definiert:The regular expression pattern \[([^\[\]]+)\] is defined like this:

MusterPattern BeschreibungDescription
\[ Entspricht einer öffnenden Klammer.Match an opening bracket.
([^\[\]]+) Entsprechung für ein beliebiges Zeichen, das keine öffnende oder schließende eckige Klammer ist, einmal oder mehrmals.Match any character that is not an opening or a closing bracket one or more times. Dies ist die erste Erfassungsgruppe.This is the first capturing group.
\] Entsprechung für eine schließende Klammer.Match a closing bracket.

Die Regex.Split-Methode ist nahezu identisch mit String.Split, mit der Ausnahme, dass Sie eine Zeichenfolge auf Grundlage eines Musters für reguläre Ausdrücke anstelle eines festen Zeichensatzes aufteilt.The Regex.Split method is almost identical to String.Split, except that it splits a string based on a regular expression pattern instead of a fixed character set. Im folgenden Beispiel wird z. b. die Regex.Split-Methode verwendet, um eine Zeichenfolge aufzuteilen, die Teil Zeichenfolgen enthält, die durch verschiedene Kombinationen von Bindestrichen und anderen Zeichen getrennt sind.For example, the following example uses the Regex.Split method to split a string that contains substrings delimited by various combinations of hyphens and other characters.

String input = "abacus -- alabaster - * - atrium -+- " +
               "any -*- actual - + - armoire - - alarm";
String pattern = @"\s-\s?[+*]?\s?-\s";
String[] elements = System.Text.RegularExpressions.Regex.Split(input, pattern);
foreach (var element in elements)
   Console.WriteLine(element);

// The example displays the following output:
//       abacus
//       alabaster
//       atrium
//       any
//       actual
//       armoire
//       alarm
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "abacus -- alabaster - * - atrium -+- " +
                            "any -*- actual - + - armoir - - alarm"
      Dim pattern As String = "\s-\s?[+*]?\s?-\s"
      Dim elements() As String = Regex.Split(input, pattern)
      For Each element In elements
         Console.WriteLine(element)
      Next
   End Sub
End Module
' The example displays the following output:
'       abacus
'       alabaster
'       atrium
'       any
'       actual
'       armoir
'       alarm

Das Muster für reguläre Ausdrücke \s-\s?[+*]?\s?-\s wie folgt definiert:The regular expression pattern \s-\s?[+*]?\s?-\s is defined like this:

MusterPattern BeschreibungDescription
\s- Entspricht einem Leerzeichen, gefolgt von einem Bindestrich.Match a white-space character followed by a hyphen.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.Match zero or one white-space character.
[+*]? Entsprechung für NULL oder ein Vorkommen des Zeichens "+" oder "*".Match zero or one occurrence of either the + or * character.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.Match zero or one white-space character.
-\s Entspricht einem Bindestrich, gefolgt von einem Leerzeichen.Match a hyphen followed by a white-space character.

Suchmethoden und die Substring-MethodeSearch methods and the Substring method

Wenn Sie nicht an allen Teil Zeichenfolgen in einer Zeichenfolge interessiert sind, empfiehlt es sich, mit einer der Methoden für den Zeichen folgen Vergleich zu arbeiten, die den Index zurückgibt, bei dem die Überprüfung beginnt.If you aren't interested in all of the substrings in a string, you might prefer to work with one of the string comparison methods that returns the index at which the match begins. Sie können dann die Substring-Methode aufzurufen, um die gewünschte Teil Zeichenfolge zu extrahieren.You can then call the Substring method to extract the substring that you want. Die Methoden für den Zeichen folgen Vergleich umfassen Folgendes:The string comparison methods include:

  • IndexOf, der den NULL basierten Index des ersten Vorkommens eines Zeichens oder einer Zeichenfolge in einer Zeichen folgen Instanz zurückgibt.IndexOf, which returns the zero-based index of the first occurrence of a character or string in a string instance.

  • IndexOfAny, der den NULL basierten Index in der aktuellen Zeichen folgen Instanz des ersten Vorkommens eines beliebigen Zeichens in einem Zeichen Array zurückgibt.IndexOfAny, which returns the zero-based index in the current string instance of the first occurrence of any character in a character array.

  • LastIndexOf, der den NULL basierten Index des letzten Vorkommens eines Zeichens oder einer Zeichenfolge in einer Zeichen folgen Instanz zurückgibt.LastIndexOf, which returns the zero-based index of the last occurrence of a character or string in a string instance.

  • LastIndexOfAny, die einen NULL basierten Index in der aktuellen Zeichen folgen Instanz des letzten Vorkommens eines beliebigen Zeichens in einem Zeichen Array zurückgibt.LastIndexOfAny, which returns a zero-based index in the current string instance of the last occurrence of any character in a character array.

Im folgenden Beispiel wird die IndexOf-Methode verwendet, um die Zeiträume in einer Zeichenfolge zu suchen.The following example uses the IndexOf method to find the periods in a string. Anschließend wird die Substring-Methode verwendet, um vollständige Sätze zurückzugeben.It then uses the Substring method to return full sentences.

String value = "This is the first sentence in a string. " +
               "More sentences will follow. For example, " +
               "this is the third sentence. This is the " +
               "fourth. And this is the fifth and final " +
               "sentence.";
var sentences = new List<String>();
int position = 0;
int start = 0;
// Extract sentences from the string.
do 
{
   position = value.IndexOf('.', start);
   if (position >= 0) 
   {
      sentences.Add(value.Substring(start, position - start + 1).Trim());
      start = position + 1;
   }
} while (position > 0);

// Display the sentences.
foreach (var sentence in sentences)
   Console.WriteLine(sentence);

// The example displays the following output:
//       This is the first sentence in a string.
//       More sentences will follow.
//       For example, this is the third sentence.
//       This is the fourth.
//       And this is the fifth and final sentence.
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim value As String = "This is the first sentence in a string. " +
                            "More sentences will follow. For example, " +
                            "this is the third sentence. This is the " +
                            "fourth. And this is the fifth and final " +
                            "sentence."
      Dim sentences As New List(Of String)
      Dim position As Integer = 0
      Dim start As Integer = 0
      ' Extract sentences from the string.
      Do
         position = value.IndexOf("."c, start)
         If position >= 0 Then
            sentences.Add(value.Substring(start, position - start + 1).Trim())
            start = position + 1
         End If
      Loop While position > 0
      
      ' Display the sentences.
      For Each sentence In sentences
         Console.WriteLine(sentence)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence in a string.
'       More sentences will follow.
'       For example, this is the third sentence.
'       This is the fourth.
'       And this is the fifth and final sentence.

Split(Char[], Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number of substrings based on the characters in an array.

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

Parameter

separator
Char[]

Ein Zeichenarray, das die Teilzeichenfolgen in dieser Zeichenfolge trennt, ein leeres Array ohne Trennzeichen oder null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.The maximum number of substrings to return.

options
StringSplitOptions

RemoveEmptyEntries, wenn leere Arrayelemente aus dem zurückgegebenen Array ausgelassen werden sollen, oder None, wenn leere Arrayelemente in das zurückgegebene Array eingeschlossen werden sollen.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

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.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Weitere Informationen finden Sie im Abschnitt "Hinweise".For more information, see the Remarks section.

Attribute

Ausnahmen

count ist ein negativer Wert.count is negative.

options entspricht keinem der StringSplitOptions-Werte.options is not one of the StringSplitOptions values.

Beispiele

Im folgenden Beispiel wird die StringSplitOptions-Enumeration verwendet, um von der Split-Methode generierte Teil Zeichenfolgen einzuschließen oder auszuschließen.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' 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
End Class
'
'This example produces the following results:
'
'1) Split a string delimited by characters:
'
'1a )The original string is ",ONE,,TWO,,,THREE,,".
'The delimiter character is ','.
'
'1b) Split a string delimited by characters and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'1c) Split a string delimited by characters and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'1d) Split a string delimited by characters and return 2 elements:
'The return value contains these 2 elements:
'<><ONE,,TWO,,,THREE,,>
'
'1e) Split a string delimited by characters and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO,,,THREE,,>
'
'2) Split a string delimited by another string:
'
'2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'The delimiter string is "[stop]".
'
'2b) Split a string delimited by another string and return all elements:
'The return value contains these 9 elements:
'<><ONE><><TWO><><><THREE><><>
'
'2c) Split a string delimited by another string and return all non-empty elements:
'The return value contains these 3 elements:
'<ONE><TWO><THREE>
'
'2d) Split a string delimited by another string and return 2 elements:
'The return value contains these 2 elements:
'<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>
'
'2e) Split a string delimited by another string and return 2 non-empty elements:
'The return value contains these 2 elements:
'<ONE><TWO[stop][stop][stop]THREE[stop][stop]>
'

Hinweise

Trennzeichen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.Delimiter characters are not included in the elements of the returned array.

Wenn diese Instanz keines der Zeichen in separatorenthält oder der count Parameter 1 ist, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.If this instance does not contain any of the characters in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. Wenn der separator-Parameter null ist oder keine Zeichen enthält, wird davon ausgegangen, dass Leerzeichen als Trennzeichen verwendet werden.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch den Unicode-Standard definiert und geben true zurück, wenn Sie an die Char.IsWhiteSpace-Methode übermittelt werden.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Wenn der separator-Parameter im Aufrufen dieser Methoden Überladung jedoch nullist, misslingt die compilerüberladungs Auflösung.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Um die aufgerufene Methode eindeutig zu identifizieren, muss der Code den Typ der NULL angeben.To unambiguously identify the called method, your code must indicate the type of the null. Im folgenden Beispiel werden mehrere Möglichkeiten zum eindeutigen Identifizieren dieser Überladung veranschaulicht.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(Char[]), 3, StringSplitOptions.RemoveEmptyEntries);

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

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

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

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

Wenn der count-Parameter 0 (null) ist, oder wenn der options-Parameter RemoveEmptyEntries ist und die Länge dieser Instanz 0 (null) ist, wird ein leeres Array zurückgegeben.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Jedes Element von separator definiert ein separates Trennzeichen.Each element of separator defines a separate delimiter character. Wenn der options-Parameter Noneist und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Array Element Empty.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Wenn in dieser Instanz mehr als count Teil Zeichenfolgen vorhanden sind, werden die ersten count minus 1 Teil Zeichenfolgen in den ersten count minus 1 Elementen des Rückgabewerts zurückgegeben, und die restlichen Zeichen in dieser Instanz werden im letzten Element des Rückgabewerts zurückgegeben.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Wenn count größer als die Anzahl der Teil Zeichenfolgen ist, werden die verfügbaren Teil Zeichenfolgen zurückgegeben, und es wird keine Ausnahme ausgelöst.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Überlegungen zur LeistungPerformance Considerations

Die Split-Methoden weisen Speicher für das zurückgegebene Array Objekt und ein String-Objekt für jedes Array Element zu.The Split methods allocate memory for the returned array object and a String object for each array element. Wenn Ihre Anwendung eine optimale Leistung erfordert oder wenn die Verwaltung der Speicher Belegung in der Anwendung wichtig ist, sollten Sie die IndexOf-oder IndexOfAny Methode und optional die Compare-Methode verwenden, um eine Teil Zeichenfolge innerhalb einer Zeichenfolge zu suchen.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Wenn Sie eine Zeichenfolge mit einem Trennzeichen teilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um ein Trennzeichen in der Zeichenfolge zu suchen.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Wenn Sie eine Zeichenfolge in eine Trenn Zeichenfolge aufteilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um das erste Zeichen der Trenn Zeichenfolge zu suchen.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Verwenden Sie dann die Compare-Methode, um zu bestimmen, ob die Zeichen nach dem ersten Zeichen gleich den verbleibenden Zeichen der Trenn Zeichenfolge sind.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Wenn außerdem die gleichen Zeichen folgen zum Aufteilen von Zeichen folgen in mehreren Split Methoden aufrufen verwendet werden, sollten Sie in Erwägung gezogen werden, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Dadurch wird der zusätzliche mehr Aufwand für die einzelnen Methodenaufrufe erheblich reduziert.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

Wenn in der .NET Framework 3,5.NET Framework 3.5 und früheren Versionen der Split(Char[])-Methode ein separator an null oder keine Zeichen enthält, verwendet die-Methode einen etwas anderen Satz von Zeichen, um die Zeichenfolge zu teilen, als die Trim(Char[]) Methode zum Kürzen der Zeichenfolge verwendet.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Beginnend mit dem .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char, Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichentrennlinie in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number substrings based on the provided character separator.

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.A character that delimits the substrings in this instance.

count
Int32

Die maximale Anzahl der im Array erwarteten Elemente.The maximum number of elements expected in the array.

options
StringSplitOptions

Einer der Enumerationswerte, der bestimmt, ob beim SPLIT-Vorgang leere Teilzeichenfolgen im Rückgabewert weggelassen werden sollen.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Gibt zurück

String[]

Ein Array, dessen Elemente maximal count Teilzeichenfolgen von dieser Instanz enthält, die durch separator getrennt sind.An array whose elements contain at most count substrings from this instance that are delimited by separator.

Hinweise

Wenn die Zeichenfolge bereits count-1-mal geteilt wurde, das Ende der Zeichenfolge aber nicht erreicht wurde, enthält die letzte Zeichenfolge im zurückgegebenen Array die verbleibende nachfolgende Teil Zeichenfolge dieser Instanz unverändert.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Split(String[], Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number of substrings based on the strings in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.You can specify whether the substrings include empty array elements.

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

Parameter

separator
String[]

Ein Array mit Zeichenfolgen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array ohne Trennzeichen oder null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.The maximum number of substrings to return.

options
StringSplitOptions

RemoveEmptyEntries, wenn leere Arrayelemente aus dem zurückgegebenen Array ausgelassen werden sollen, oder None, wenn leere Arrayelemente in das zurückgegebene Array eingeschlossen werden sollen.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

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.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Weitere Informationen finden Sie im Abschnitt "Hinweise".For more information, see the Remarks section.

Attribute

Ausnahmen

count ist ein negativer Wert.count is negative.

options entspricht keinem der StringSplitOptions-Werte.options is not one of the StringSplitOptions values.

Beispiele

Im folgenden Beispiel wird die StringSplitOptions-Enumeration verwendet, um von der Split-Methode generierte Teil Zeichenfolgen einzuschließen oder auszuschließen.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' 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
End Class
'
'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

Rückgabewert DetailsReturn value details

Trennzeichen-Zeichen folgen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.Delimiter strings are not included in the elements of the returned array.

Wenn diese Instanz keine der Zeichen folgen in separatorenthält oder der count Parameter 1 ist, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.If this instance does not contain any of the strings in separator, or the count parameter is 1, the returned array consists of a single element that contains this instance. Wenn der separator-Parameter null ist oder keine Zeichen enthält, wird davon ausgegangen, dass Leerzeichen als Trennzeichen verwendet werden.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch den Unicode-Standard definiert und geben true zurück, wenn Sie an die Char.IsWhiteSpace-Methode übermittelt werden.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Wenn der separator-Parameter im Aufrufen dieser Methoden Überladung jedoch nullist, misslingt die compilerüberladungs Auflösung.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Um die aufgerufene Methode eindeutig zu identifizieren, muss der Code den Typ des nullangeben.To unambiguously identify the called method, your code must indicate the type of the null. Im folgenden Beispiel werden mehrere Möglichkeiten zum eindeutigen Identifizieren dieser Überladung veranschaulicht.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

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

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

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

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

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

Wenn der count-Parameter 0 (null) ist, oder wenn der options-Parameter RemoveEmptyEntries ist und die Länge dieser Instanz 0 (null) ist, wird ein leeres Array zurückgegeben.If the count parameter is zero, or the options parameter is RemoveEmptyEntries and the length of this instance is zero, an empty array is returned.

Jedes Element von separator definiert ein separates Trennzeichen, das aus einem oder mehreren Zeichen besteht.Each element of separator defines a separate delimiter that consists of one or more characters. Wenn der options-Parameter Noneist und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Array Element Empty.If the options parameter is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Wenn in dieser Instanz mehr als count Teil Zeichenfolgen vorhanden sind, werden die ersten count minus 1 Teil Zeichenfolgen in den ersten count minus 1 Elementen des Rückgabewerts zurückgegeben, und die restlichen Zeichen in dieser Instanz werden im letzten Element des Rückgabewerts zurückgegeben.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Wenn count größer als die Anzahl der Teil Zeichenfolgen ist, werden die verfügbaren Teil Zeichenfolgen zurückgegeben, und es wird keine Ausnahme ausgelöst.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Das Trennzeichen ArrayThe separator array

Wenn eines der Elemente in separator aus mehreren Zeichen besteht, gilt die gesamte Teil Zeichenfolge als Trennzeichen.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Wenn eines der Elemente in separator z. b. "10" ist, wird versucht, die Zeichenfolge "This10is10a10string" aufzuteilen.For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." gibt dieses Array mit vier Elementen zurück: {"This", "is", "a", "String".returns this four-element array: { "This", "is", "a", "string." }.}.

Vergleichs DetailsComparison details

Die Split-Methode extrahiert die Teil Zeichenfolgen in dieser Zeichenfolge, die durch eine oder mehrere der Zeichen folgen im separator-Parameter getrennt sind, und gibt diese Teil Zeichenfolgen als Elemente eines Arrays zurück.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Die Split-Methode sucht nach Trennzeichen, indem Sie Vergleiche mithilfe von ordinalsortierungs Regeln für die Groß-und Kleinschreibung durchführtThe Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Weitere Informationen zu Wort-, Zeichen folgen-und ordinalsortierungen finden Sie in der System.Globalization.CompareOptions-Enumeration.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Die Split-Methode ignoriert jedes Element separator, dessen Wert null oder die leere Zeichenfolge ("") ist.The Split method ignores any element of separator whose value is null or the empty string ("").

Um mehrdeutige Ergebnisse zu vermeiden, wenn Zeichen folgen in separator Zeichen gemeinsam haben, fährt die Split-Methode von Anfang bis Ende des Werts der-Instanz fort und entspricht dem ersten Element in separator, das gleich einem Trennzeichen in der-Instanz ist.To avoid ambiguous results when strings in separator have characters in common, the Split method proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. Die Reihenfolge, in der Teil Zeichenfolgen in der Instanz gefunden werden, hat Vorrang vor der Reihenfolge der Elemente in separator.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Stellen Sie sich z. b. eine Instanz vor, deren Wert "abcdef" ist.For example, consider an instance whose value is "abcdef". Wenn das erste Element in separator "EF" und das zweite Element "bcde" war, wäre das Ergebnis des Split-Vorgangs "a" und "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be "a" and "f". Dies liegt daran, dass die Teil Zeichenfolge in der-Instanz, "bcde", gefunden wird und mit einem Element in separator übereinstimmt, bevor die Teil Zeichenfolge "f" gefunden wird.This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Wenn das erste Element von separator jedoch "BCD" und das zweite Element "BC" war, würde das Ergebnis des Split-Vorgangs "a" und "EF" lauten.However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be "a" and "ef". Dies liegt daran, dass "BCD" das erste Trennzeichen in separator ist, das mit einem Trennzeichen in der-Instanz übereinstimmt.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Wenn die Reihenfolge der Trennzeichen umgekehrt wurde, sodass das erste Element "BC" und das zweite Element "BCD" war, wäre das Ergebnis "a" und "Def".If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be "a" and "def".

Überlegungen zur LeistungPerformance considerations

Die Split-Methoden weisen Speicher für das zurückgegebene Array Objekt und ein String-Objekt für jedes Array Element zu.The Split methods allocate memory for the returned array object and a String object for each array element. Wenn Ihre Anwendung eine optimale Leistung erfordert oder wenn die Verwaltung der Speicher Belegung in der Anwendung wichtig ist, sollten Sie die IndexOf-oder IndexOfAny Methode und optional die Compare-Methode verwenden, um eine Teil Zeichenfolge innerhalb einer Zeichenfolge zu suchen.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Wenn Sie eine Zeichenfolge mit einem Trennzeichen teilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um ein Trennzeichen in der Zeichenfolge zu suchen.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Wenn Sie eine Zeichenfolge in eine Trenn Zeichenfolge aufteilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um das erste Zeichen der Trenn Zeichenfolge zu suchen.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Verwenden Sie dann die Compare-Methode, um zu bestimmen, ob die Zeichen nach dem ersten Zeichen gleich den verbleibenden Zeichen der Trenn Zeichenfolge sind.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Wenn außerdem die gleichen Zeichen folgen zum Aufteilen von Zeichen folgen in mehreren Split Methoden aufrufen verwendet werden, sollten Sie in Erwägung gezogen werden, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Dadurch wird der zusätzliche mehr Aufwand für die einzelnen Methodenaufrufe erheblich reduziert.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

Wenn in der .NET Framework 3,5.NET Framework 3.5 und früheren Versionen der Split(Char[])-Methode ein separator an null oder keine Zeichen enthält, verwendet die-Methode einen etwas anderen Satz von Zeichen, um die Zeichenfolge zu teilen, als die Trim(Char[]) Methode zum Kürzen der Zeichenfolge verwendet.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Beginnend mit dem .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String[], StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in Teilzeichenfolgen.Splits a string into substrings based on the strings in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.You can specify whether the substrings include empty array elements.

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

Parameter

separator
String[]

Ein Array mit Zeichenfolgen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array ohne Trennzeichen oder null.A string array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

RemoveEmptyEntries, wenn leere Arrayelemente aus dem zurückgegebenen Array ausgelassen werden sollen, oder None, wenn leere Arrayelemente in das zurückgegebene Array eingeschlossen werden sollen.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

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.An array whose elements contain the substrings in this string that are delimited by one or more strings in separator. Weitere Informationen finden Sie im Abschnitt "Hinweise".For more information, see the Remarks section.

Attribute

Ausnahmen

options entspricht keinem der StringSplitOptions-Werte.options is not one of the StringSplitOptions values.

Beispiele

Im folgenden Beispiel wird der Unterschied in den Arrays veranschaulicht, die durch Aufrufen der String.Split(String[], StringSplitOptions)-Methode einer Zeichenfolge zurückgegeben werden, deren options-Parameter gleich StringSplitOptions.None und StringSplitOptions.RemoveEmptyEntriesist.The following example illustrates the difference in the arrays returned by calling a string's String.Split(String[], StringSplitOptions) method with its options parameter equal to StringSplitOptions.None and StringSplitOptions.RemoveEmptyEntries.

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

   // Split delimited by another string and return all non-empty elements.
   result = source.Split(stringSeparators, 
                         StringSplitOptions.RemoveEmptyEntries);
   Console.WriteLine("Result including non-empty elements ({0} elements):", 
                     result.Length);
   Console.Write("   ");
   foreach (string s in result)
   {
      Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
   }
   Console.WriteLine();

   // The example displays the following output:
   //    Splitting the string:
   //       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
   //    
   //    Using the delimiter string:
   //       "[stop]"
   //    
   //    Result including all elements (9 elements):
   //       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
   //    
   //    Result including non-empty elements (3 elements):
   //       'ONE' 'TWO' 'THREE'
Module Example
   Public Sub Main()
      Dim source As String = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
      Dim stringSeparators() As String = {"[stop]"}
      Dim result() As String
      
      ' Display the original string and delimiter string.
      Console.WriteLine("Splitting the string:{0}   '{1}'.", vbCrLf, source)
      Console.WriteLine()
      Console.WriteLine("Using the delimiter string:{0}   '{1}'.", _
                        vbCrLf, stringSeparators(0))
      Console.WriteLine()                          
         
      ' Split a string delimited by another string and return all elements.
      result = source.Split(stringSeparators, StringSplitOptions.None)
      Console.WriteLine("Result including all elements ({0} elements):", _ 
                        result.Length)
      Console.Write("   ")
      For Each s As String In result
         Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))                   
      Next
      Console.WriteLine()
      Console.WriteLine()

      ' Split delimited by another string and return all non-empty elements.
      result = source.Split(stringSeparators, _ 
                            StringSplitOptions.RemoveEmptyEntries)
      Console.WriteLine("Result including non-empty elements ({0} elements):", _ 
                        result.Length)
      Console.Write("   ")
      For Each s As String In result
         Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))                   
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Splitting the string:
'       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'    
'    Using the delimiter string:
'       "[stop]"
'    
'    Result including all elements (9 elements):
'       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
'    
'    Result including non-empty elements (3 elements):
'       'ONE' 'TWO' 'THREE'

Im folgenden Beispiel wird ein Array von Trennzeichen definiert, das Interpunktions-und Leerzeichen enthält.The following example defines an array of separators that include punctuation and white-space characters. Wenn Sie dieses Array zusammen mit dem Wert StringSplitOptions.RemoveEmptyEntries an die Split(String[], StringSplitOptions) Methode übergeben, wird ein Array zurückgegeben, das aus den einzelnen Wörtern aus der Zeichenfolge besteht.Passing this array along with a value of StringSplitOptions.RemoveEmptyEntries to the Split(String[], StringSplitOptions) method returns an array that consists of the individual words from the string.

string[] separators = {",", ".", "!", "?", ";", ":", " "};
string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in words)
   Console.WriteLine(word);
   
// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate
Module Example
   Public Sub Main()
      Dim separators() As String = {",", ".", "!", "?", ";", ":", " "}
      Dim value As String = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
      Dim words() As String = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
      For Each word In words
         Console.WriteLine(word)
      Next   
   End Sub
End Module
' The example displays the following output:
'       The
'       handsome
'       energetic
'       young
'       dog
'       was
'       playing
'       with
'       his
'       smaller
'       more
'       lethargic
'       litter
'       mate

Beachten Sie, dass die-Methode aufgerufen wird, wobei das options Argument auf StringSplitOptions.RemoveEmptyEntriesfestgelegt ist.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. Dadurch wird verhindert, dass das zurückgegebene Array String.Empty Werte einschließt, die leere Teil Zeichenfolgen-Übereinstimmungen zwischen Interpunktions Zeichen und Leerzeichen darstellen.This prevents the returned array from including String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Hinweise

Wenn eine Zeichenfolge durch einen bekannten Satz von Zeichen folgen getrennt ist, können Sie die Split-Methode verwenden, um Sie in Teil Zeichenfolgen zu trennen.When a string is delimited by a known set of strings, you can use the Split method to separate it into substrings.

Rückgabewert DetailsReturn value details

Trennzeichen-Zeichen folgen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.Delimiter strings are not included in the elements of the returned array. Wenn das separator Array z. b. die Zeichenfolge "--" enthält und der Wert der aktuellen Zeichen folgen Instanz "AA--BB-CC" ist, gibt die Methode ein Array zurück, das drei Elemente enthält: "AA", "BB" und "CC".For example, if the separator array includes the string "--" and the value of the current string instance is "aa--bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Wenn diese Instanz keine der Zeichen folgen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.If this instance does not contain any of the strings in separator, the returned array consists of a single element that contains this instance.

Wenn der options-Parameter RemoveEmptyEntries ist und die Länge dieser Instanz 0 (null) ist, gibt die Methode ein leeres Array zurück.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Jedes Element von separator definiert ein separates Trennzeichen, das aus einem oder mehreren Zeichen besteht.Each element of separator defines a separate delimiter that consists of one or more characters. Wenn das options-Argument Noneist und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Array Element String.Empty.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Wenn separator z. b. zwei Elemente enthält: "-" und "_", ist der Wert der Zeichen folgen Instanz "-_AA-_", und der Wert des options Arguments ist None. die Methode gibt ein Sting-Array mit den folgenden fünf Elementen zurück. :For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a sting array with the following five elements:

  1. String.Empty, die die leere Zeichenfolge darstellt, die der "-"-Teil Zeichenfolge bei Index 0 vorangestellt ist.String.Empty, which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty, das die leere Zeichenfolge zwischen der "-"-Teil Zeichenfolge bei Index 0 und der Teil Zeichenfolge "" bei Index 1 darstellt.String.Empty, which represents the empty string between the "-" substring at index 0 and the "" substring at index 1.

  3. "aa","aa",

  4. String.Empty, die die leere Zeichenfolge darstellt, die auf die Teil Zeichenfolge "" bei Index 4 folgt.String.Empty, which represents the empty string that follows the "" substring at index 4.

  5. String.Empty, die die leere Zeichenfolge darstellt, die auf die Teil Zeichenfolge "-" bei Index 5 folgt.String.Empty, which represents the empty string that follows the "-" substring at index 5.

Das Trennzeichen ArrayThe separator array

Wenn eines der Elemente in separator aus mehreren Zeichen besteht, gilt die gesamte Teil Zeichenfolge als Trennzeichen.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Wenn eines der Elemente in separator z. b. "10" ist, wird versucht, die Zeichenfolge "This10is10a10string" aufzuteilen.For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." Gibt das folgende Array von vier Elementen zurück: {"This", "is", "a", "String".returns the following four-element array: { "This", "is", "a", "string." }.}.

Wenn der separator-Parameter null ist oder keine Zeichen enthält, wird davon ausgegangen, dass Leerzeichen als Trennzeichen verwendet werden.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch den Unicode-Standard definiert und geben true zurück, wenn Sie an die Char.IsWhiteSpace-Methode übermittelt werden.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Wenn der separator-Parameter im Aufrufen dieser Methoden Überladung nullist, misslingt die compilerüberladungs Auflösung.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Um die aufgerufene Methode eindeutig zu identifizieren, muss der Code den Typ des nullangeben.To unambiguously identify the called method, your code must indicate the type of the null. Im folgenden Beispiel werden mehrere Möglichkeiten zum eindeutigen Identifizieren dieser Überladung veranschaulicht.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

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

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

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

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

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

Vergleichs DetailsComparison details

Die Split-Methode extrahiert die Teil Zeichenfolgen in dieser Zeichenfolge, die durch eine oder mehrere der Zeichen folgen im separator-Parameter getrennt sind, und gibt diese Teil Zeichenfolgen als Elemente eines Arrays zurück.The Split method extracts the substrings in this string that are delimited by one or more of the strings in the separator parameter, and returns those substrings as elements of an array.

Die Split-Methode sucht nach Trennzeichen, indem Sie Vergleiche mithilfe von ordinalsortierungs Regeln für die Groß-und Kleinschreibung durchführtThe Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Weitere Informationen zu Wort-, Zeichen folgen-und ordinalsortierungen finden Sie in der System.Globalization.CompareOptions-Enumeration.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Die Split-Methode ignoriert jedes Element separator, dessen Wert null oder die leere Zeichenfolge ("") ist.The Split method ignores any element of separator whose value is null or the empty string ("").

Um mehrdeutige Ergebnisse zu vermeiden, wenn Zeichen folgen in separator Zeichen gemeinsam haben, wird der Split Vorgang von Anfang bis zum Ende des Werts der-Instanz fortgesetzt und entspricht dem ersten Element in separator, das gleich einem Trennzeichen in der-Instanz ist.To avoid ambiguous results when strings in separator have characters in common, the Split operation proceeds from the beginning to the end of the value of the instance, and matches the first element in separator that is equal to a delimiter in the instance. Die Reihenfolge, in der Teil Zeichenfolgen in der Instanz gefunden werden, hat Vorrang vor der Reihenfolge der Elemente in separator.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Stellen Sie sich z. b. eine Instanz vor, deren Wert "abcdef" ist.For example, consider an instance whose value is "abcdef". Wenn das erste Element in separator "EF" und das zweite Element "bcde" war, wäre das Ergebnis des Split-Vorgangs ein Zeichen folgen Array, das zwei Elemente enthält: "a" und "f".If the first element in separator was "ef" and the second element was "bcde", the result of the split operation would be a string array that contains two elements, "a" and "f". Dies liegt daran, dass die Teil Zeichenfolge in der-Instanz, "bcde", gefunden wird und mit einem Element in separator übereinstimmt, bevor die Teil Zeichenfolge "f" gefunden wird.This is because the substring in the instance, "bcde", is encountered and matches an element in separator before the substring "f" is encountered.

Wenn das erste Element von separator jedoch "BCD" und das zweite Element "BC" war, wäre das Ergebnis des Split-Vorgangs ein Zeichen folgen Array, das zwei Elemente enthält: "a" und "EF".However, if the first element of separator was "bcd" and the second element was "bc", the result of the split operation would be a string array that contains two elements, "a" and "ef". Dies liegt daran, dass "BCD" das erste Trennzeichen in separator ist, das mit einem Trennzeichen in der-Instanz übereinstimmt.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Wenn die Reihenfolge der Trennzeichen umgekehrt wurde, sodass das erste Element "BC" und das zweite Element "BCD" war, wäre das Ergebnis ein Zeichen folgen Array, das zwei Elemente enthält: "a" und "Def".If the order of the separators was reversed so the first element was "bc" and the second element was "bcd", the result would be a string array that contains two elements, "a" and "def".

Überlegungen zur LeistungPerformance considerations

Die Split-Methoden weisen Speicher für das zurückgegebene Array Objekt und ein String-Objekt für jedes Array Element zu.The Split methods allocate memory for the returned array object and a String object for each array element. Wenn Ihre Anwendung eine optimale Leistung erfordert oder wenn die Verwaltung der Speicher Belegung in der Anwendung wichtig ist, sollten Sie die IndexOf-oder IndexOfAny Methode und optional die Compare-Methode verwenden, um eine Teil Zeichenfolge innerhalb einer Zeichenfolge zu suchen.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Wenn Sie eine Zeichenfolge mit einem Trennzeichen teilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um ein Trennzeichen in der Zeichenfolge zu suchen.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Wenn Sie eine Zeichenfolge in eine Trenn Zeichenfolge aufteilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um das erste Zeichen der Trenn Zeichenfolge zu suchen.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Verwenden Sie dann die Compare-Methode, um zu bestimmen, ob die Zeichen nach dem ersten Zeichen gleich den verbleibenden Zeichen der Trenn Zeichenfolge sind.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Wenn außerdem die gleichen Zeichen folgen zum Aufteilen von Zeichen folgen in mehreren Split Methoden aufrufen verwendet werden, sollten Sie in Erwägung gezogen werden, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Dadurch wird der zusätzliche mehr Aufwand für die einzelnen Methodenaufrufe erheblich reduziert.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

Wenn in der .NET Framework 3,5.NET Framework 3.5 und früheren Versionen der Split(Char[])-Methode ein separator an null oder keine Zeichen enthält, verwendet die-Methode einen etwas anderen Satz von Zeichen, um die Zeichenfolge zu teilen, als die Trim(Char[]) Methode zum Kürzen der Zeichenfolge verwendet.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Beginnend mit dem .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String, Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number of substrings based on the provided string separator.

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.A string that delimits the substrings in this instance.

count
Int32

Die maximale Anzahl der im Array erwarteten Elemente.The maximum number of elements expected in the array.

options
StringSplitOptions

Einer der Enumerationswerte, der bestimmt, ob beim SPLIT-Vorgang leere Teilzeichenfolgen im Rückgabewert weggelassen werden sollen.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Gibt zurück

String[]

Ein Array, dessen Elemente maximal count Teilzeichenfolgen von dieser Instanz enthält, die durch separator getrennt sind.An array whose elements contain at most count substrings from this instance that are delimited by separator.

Hinweise

Wenn die Zeichenfolge bereits count-1-mal geteilt wurde, das Ende der Zeichenfolge aber nicht erreicht wurde, enthält die letzte Zeichenfolge im zurückgegebenen Array die verbleibende nachfolgende Teil Zeichenfolge dieser Instanz unverändert.If the string has already been split count - 1 times, but the end of the string has not been reached, then the last string in the returned array will contain this instance's remaining trailing substring, untouched.

Split(Char[], StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen.Splits a string into substrings based on the characters in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.You can specify whether the substrings include empty array elements.

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

Parameter

separator
Char[]

Ein Zeichenarray, das die Teilzeichenfolgen in dieser Zeichenfolge trennt, ein leeres Array ohne Trennzeichen oder null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

options
StringSplitOptions

RemoveEmptyEntries, wenn leere Arrayelemente aus dem zurückgegebenen Array ausgelassen werden sollen, oder None, wenn leere Arrayelemente in das zurückgegebene Array eingeschlossen werden sollen.RemoveEmptyEntries to omit empty array elements from the array returned; or None to include empty array elements in the array returned.

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.An array whose elements contain the substrings in this string that are delimited by one or more characters in separator. Weitere Informationen finden Sie im Abschnitt "Hinweise".For more information, see the Remarks section.

Attribute

Ausnahmen

options entspricht keinem der StringSplitOptions-Werte.options is not one of the StringSplitOptions values.

Beispiele

Im folgenden Beispiel wird die StringSplitOptions-Enumeration verwendet, um von der Split-Methode generierte Teil Zeichenfolgen einzuschließen oder auszuschließen.The following example uses the StringSplitOptions enumeration to include or exclude substrings generated by the Split method.

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

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

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

/*
This example produces the following results:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim s1 As String = ",ONE,,TWO,,,THREE,,"
        Dim s2 As String = "[stop]" & _
                           "ONE[stop][stop]" & _
                           "TWO[stop][stop][stop]" & _
                           "THREE[stop][stop]"
        Dim charSeparators() As Char = {","c}
        Dim stringSeparators() As String = {"[stop]"}
        Dim result() As String
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by characters.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
        
        ' Display the original string and delimiter characters.
        Console.WriteLine("1a )The original string is ""{0}"".", s1)
        Console.WriteLine("The delimiter character is '{0}'." & vbCrLf, charSeparators(0))
        
        ' Split a string delimited by characters and return all elements.
        Console.WriteLine("1b) Split a string delimited by characters and " & _
                          "return all elements:")
        result = s1.Split(charSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split a string delimited by characters and return all non-empty elements.
        Console.WriteLine("1c) Split a string delimited by characters and " & _
                          "return all non-empty elements:")
        result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the string and empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("1d) Split a string delimited by characters and " & _
                          "return 2 elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("1e) Split a string delimited by characters and " & _
                          "return 2 non-empty elements:")
        result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' ------------------------------------------------------------------------------
        ' Split a string delimited by another string.
        ' ------------------------------------------------------------------------------
        Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
        
        ' Display the original string and delimiter string.
        Console.WriteLine("2a) The original string is ""{0}"".", s2)
        Console.WriteLine("The delimiter string is ""{0}""." & vbCrLf, stringSeparators(0))
        
        ' Split a string delimited by another string and return all elements.
        Console.WriteLine("2b) Split a string delimited by another string and " & _
                          "return all elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string at the delimiter and return all non-empty elements.
        Console.WriteLine("2c) Split a string delimited by another string and " & _
                          "return all non-empty elements:")
        result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
        
        ' Split the original string into the empty string before the 
        ' delimiter and the remainder of the original string after the delimiter.
        Console.WriteLine("2d) Split a string delimited by another string and " & _
                          "return 2 elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
        Show(result)
        
        ' Split the original string into the string after the delimiter and the 
        ' remainder of the original string after the delimiter.
        Console.WriteLine("2e) Split a string delimited by another string and " & _
                          "return 2 non-empty elements:")
        result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
        Show(result)
    
    End Sub
    
    
    ' 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
End Class
'
'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

Rückgabewert DetailsReturn value details

Trennzeichen (die Zeichen im separator Array) sind nicht in den Elementen des zurückgegebenen Arrays enthalten.Delimiter characters (the characters in the separator array) are not included in the elements of the returned array. Wenn das separator Array z. b. das Zeichen "-" enthält und der Wert der aktuellen Zeichen folgen Instanz "AA-BB-CC" ist, gibt die Methode ein Array zurück, das drei Elemente enthält: "AA", "BB" und "CC".For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Wenn diese Instanz keines der Zeichen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Wenn der options-Parameter RemoveEmptyEntries ist und die Länge dieser Instanz 0 (null) ist, gibt die Methode ein leeres Array zurück.If the options parameter is RemoveEmptyEntries and the length of this instance is zero, the method returns an empty array.

Jedes Element von separator definiert ein separates Trennzeichen, das aus einem einzelnen Zeichen besteht.Each element of separator defines a separate delimiter that consists of a single character. Wenn das options-Argument Noneist und zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Array Element String.Empty.If the options argument is None, and two delimiters are adjacent or a delimiter is found at the beginning or end of this instance, the corresponding array element contains String.Empty. Wenn separator z. b. zwei Elemente enthält: "-" und "_", ist der Wert der Zeichen folgen Instanz "-_AA-_", und der Wert des options Arguments ist None. die Methode gibt ein Zeichen folgen Array mit den folgenden fünf Elementen zurück. :For example, if separator includes two elements, "-" and "_", the value of the string instance is "-_aa-_", and the value of the options argument is None, the method returns a string array with the following five elements:

  1. String.Empty, die die leere Zeichenfolge darstellt, die dem Zeichen "-" am Index 0 vorangestellt ist.String.Empty, which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty, das die leere Zeichenfolge zwischen dem Zeichen "-" bei Index 0 und dem Zeichen "" bei Index 1 darstellt.String.Empty, which represents the empty string between the "-" character at index 0 and the "" character at index 1.

  3. "aa","aa",

  4. String.Empty, die die leere Zeichenfolge darstellt, die auf das Zeichen "" bei Index 4 folgt.String.Empty, which represents the empty string that follows the "" character at index 4.

  5. String.Empty, die die leere Zeichenfolge darstellt, die auf das Zeichen "-" am Index 5 folgt.String.Empty, which represents the empty string that follows the "-" character at index 5.

Das Trennzeichen ArrayThe separator array

Wenn der separator-Parameter null ist oder keine Zeichen enthält, wird davon ausgegangen, dass Leerzeichen als Trennzeichen verwendet werden.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch den Unicode-Standard definiert und geben true zurück, wenn Sie an die Char.IsWhiteSpace-Methode übermittelt werden.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Wenn der separator-Parameter im Aufrufen dieser Methoden Überladung nullist, misslingt die compilerüberladungs Auflösung.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Um die aufgerufene Methode eindeutig zu identifizieren, muss der Code den Typ des nullangeben.To unambiguously identify the called method, your code must indicate the type of the null. Im folgenden Beispiel werden mehrere Möglichkeiten zum eindeutigen Identifizieren dieser Überladung veranschaulicht.The following example shows several ways to unambiguously identify this overload.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(Char[]), StringSplitOptions.RemoveEmptyEntries);

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

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

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

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

Vergleichs DetailsComparison details

Die Split-Methode extrahiert die Teil Zeichenfolgen in dieser Zeichenfolge, die durch ein oder mehrere der Zeichen im Parameter separator getrennt sind, und gibt diese Teil Zeichenfolgen als Elemente eines Arrays zurück.The Split method extracts the substrings in this string that are delimited by one or more of the characters in the separator parameter, and returns those substrings as elements of an array.

Die Split-Methode sucht nach Trennzeichen, indem Sie Vergleiche mithilfe von ordinalsortierungs Regeln für die Groß-und Kleinschreibung durchführtThe Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Weitere Informationen zu Wort-, Zeichen folgen-und ordinalsortierungen finden Sie in der System.Globalization.CompareOptions-Enumeration.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Überlegungen zur LeistungPerformance Considerations

Die Split-Methoden weisen Speicher für das zurückgegebene Array Objekt und ein String-Objekt für jedes Array Element zu.The Split methods allocate memory for the returned array object and a String object for each array element. Wenn Ihre Anwendung eine optimale Leistung erfordert oder wenn die Verwaltung der Speicher Belegung in der Anwendung wichtig ist, sollten Sie die IndexOf-oder IndexOfAny Methode und optional die Compare-Methode verwenden, um eine Teil Zeichenfolge innerhalb einer Zeichenfolge zu suchen.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Wenn Sie eine Zeichenfolge mit einem Trennzeichen teilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um ein Trennzeichen in der Zeichenfolge zu suchen.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Wenn Sie eine Zeichenfolge in eine Trenn Zeichenfolge aufteilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um das erste Zeichen der Trenn Zeichenfolge zu suchen.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Verwenden Sie dann die Compare-Methode, um zu bestimmen, ob die Zeichen nach dem ersten Zeichen gleich den verbleibenden Zeichen der Trenn Zeichenfolge sind.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Wenn außerdem die gleichen Zeichen folgen zum Aufteilen von Zeichen folgen in mehreren Split Methoden aufrufen verwendet werden, sollten Sie in Erwägung gezogen werden, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Dadurch wird der zusätzliche mehr Aufwand für die einzelnen Methodenaufrufe erheblich reduziert.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

Wenn in der .NET Framework 3,5.NET Framework 3.5 und früheren Versionen der Split(Char[])-Methode ein separator an null oder keine Zeichen enthält, verwendet die-Methode einen etwas anderen Satz von Zeichen, um die Zeichenfolge zu teilen, als die Trim(Char[]) Methode zum Kürzen der Zeichenfolge verwendet.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Beginnend mit dem .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char[], Int32)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in eine maximale Anzahl von Teilzeichenfolgen.Splits a string into a maximum number of substrings based on the characters in an array. Sie geben außerdem die maximale Anzahl der zurückzugebenden Teilzeichenfolgen an.You also specify the maximum number of substrings to return.

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

Parameter

separator
Char[]

Ein Zeichenarray, das die Teilzeichenfolgen in dieser Zeichenfolge trennt, ein leeres Array ohne Trennzeichen oder null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or null.

count
Int32

Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen.The maximum number of substrings to return.

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.An array whose elements contain the substrings in this instance that are delimited by one or more characters in separator. Weitere Informationen finden Sie im Abschnitt "Hinweise".For more information, see the Remarks section.

Ausnahmen

count ist ein negativer Wert.count is negative.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie count die Anzahl der von Splitzurückgegebenen Zeichen folgen beeinflusst.The following example demonstrates how count affects the number of strings returned by Split.

string delimStr = " ,.:";
char [] delimiter = delimStr.ToCharArray();
string words = "one two,three:four.";
string [] split = null;

Console.WriteLine("The delimiters are -{0}-", delimStr);
for (int x = 1; x <= 5; x++) 
{
   split = words.Split(delimiter, x);
   Console.WriteLine("\ncount = {0,2} ..............", x);
   foreach (var s in split) 
   {
       Console.WriteLine("-{0}-", s);
   }
}

// The example displays the following output:
//       The delimiters are - ,.:-
//       count =  1 ..............
//       -one two,three:four.-
//       count =  2 ..............
//       -one-
//       -two,three:four.-
//       count =  3 ..............
//       -one-
//       -two-
//       -three:four.-
//       count =  4 ..............
//       -one-
//       -two-
//       -three-
//       -four.-
//       count =  5 ..............
//       -one-
//       -two-
//       -three-
//       -four-
//       --
Public Class StringSplit2
   Public Shared Sub Main()
      
      Dim delimStr As String = " ,.:"
      Dim delimiter As Char() = delimStr.ToCharArray()
      Dim words As String = "one two,three:four."
      Dim split As String() = Nothing
      
      Console.WriteLine("The delimiters are -{0}-", delimStr)
      Dim x As Integer
      For x = 1 To 5
         split = words.Split(delimiter, x)
         Console.WriteLine(ControlChars.Cr + "count = {0,2} ..............", x)
         Dim s As String
         For Each s In  split
            Console.WriteLine("-{0}-", s)
         Next s
      Next x
   End Sub 
End Class 
' The example displays the following output:
'       The delimiters are - ,.:-
'       count =  1 ..............
'       -one two,three:four.-
'       count =  2 ..............
'       -one-
'       -two,three:four.-
'       count =  3 ..............
'       -one-
'       -two-
'       -three:four.-
'       count =  4 ..............
'       -one-
'       -two-
'       -three-
'       -four.-
'       count =  5 ..............
'       -one-
'       -two-
'       -three-
'       -four-
'       --

Hinweise

Trennzeichen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.Delimiter characters are not included in the elements of the returned array.

Wenn diese Instanz keines der Zeichen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance. Wenn count NULL ist, wird ein leeres Array zurückgegeben.If count is zero, an empty array is returned.

Wenn der separator-Parameter null ist oder keine Zeichen enthält, wird davon ausgegangen, dass Leerzeichen als Trennzeichen verwendet werden.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch den Unicode-Standard definiert und geben true zurück, wenn Sie an die Char.IsWhiteSpace-Methode übermittelt werden.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Jedes Element von separator definiert ein separates Trennzeichen.Each element of separator defines a separate delimiter character. Wenn zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Array Element Empty.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding array element contains Empty.

Wenn in dieser Instanz mehr als count Teil Zeichenfolgen vorhanden sind, werden die ersten count minus 1 Teil Zeichenfolgen in den ersten count minus 1 Elementen des Rückgabewerts zurückgegeben, und die restlichen Zeichen in dieser Instanz werden im letzten Element des Rückgabewerts zurückgegeben.If there are more than count substrings in this instance, the first count minus 1 substrings are returned in the first count minus 1 elements of the return value, and the remaining characters in this instance are returned in the last element of the return value.

Wenn count größer als die Anzahl der Teil Zeichenfolgen ist, werden die verfügbaren Teil Zeichenfolgen zurückgegeben, und es wird keine Ausnahme ausgelöst.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

In der folgenden Tabelle finden Sie Beispiele.The following table provides examples.

Zeichen folgen WertString value TrennzeichenSeparator AnzahlCount Zurück gegebenes ArrayReturned array
"42, 12, 19""42, 12, 19" New Char [] {', ', ' '} (C#)new Char[] {',', ' '} (C#)

Char () = {"," c "," c} (Visual Basic)Char() = {","c, " "c} (Visual Basic)
22 {"42", " 12, 19"}{"42", " 12, 19"}
"42..12..19""42..12..19" new Char[] {'.'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
44 {"42", "", "12", ".19"}{"42", "", "12", ".19"}
Bananen"Banana" new Char[] {'.'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
22 {"Banana"}{"Banana"}
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
New Char [] {} (C#)new Char[] {} (C#)

Char () = {} (Visual Basic)Char() = {} (Visual Basic)
11 {"Darb\nsmarba"} (C#){"Darb\nSmarba"} (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
New Char [] NULL (C#)new Char[] null (C#)

Char () = NothingChar() = Nothing
22 {"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
New Char [] NULL (C#)new Char[] null (C#)

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

Überlegungen zur LeistungPerformance Considerations

Die Split-Methoden weisen Speicher für das zurückgegebene Array Objekt und ein String-Objekt für jedes Array Element zu.The Split methods allocate memory for the returned array object and a String object for each array element. Wenn Ihre Anwendung eine optimale Leistung erfordert oder wenn die Verwaltung der Speicher Belegung in der Anwendung wichtig ist, sollten Sie die IndexOf-oder IndexOfAny Methode und optional die Compare-Methode verwenden, um eine Teil Zeichenfolge innerhalb einer Zeichenfolge zu suchen.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method, and optionally the Compare method, to locate a substring within a string.

Wenn Sie eine Zeichenfolge mit einem Trennzeichen teilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um ein Trennzeichen in der Zeichenfolge zu suchen.If you are splitting a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Wenn Sie eine Zeichenfolge in eine Trenn Zeichenfolge aufteilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um das erste Zeichen der Trenn Zeichenfolge zu suchen.If you are splitting a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Verwenden Sie dann die Compare-Methode, um zu bestimmen, ob die Zeichen nach dem ersten Zeichen gleich den verbleibenden Zeichen der Trenn Zeichenfolge sind.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Wenn außerdem die gleichen Zeichen folgen zum Aufteilen von Zeichen folgen in mehreren Split Methoden aufrufen verwendet werden, sollten Sie in Erwägung gezogen werden, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Dadurch wird der zusätzliche mehr Aufwand für die einzelnen Methodenaufrufe erheblich reduziert.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

Wenn in der .NET Framework 3,5.NET Framework 3.5 und früheren Versionen der Split(Char[])-Methode ein separator an null oder keine Zeichen enthält, verwendet die-Methode einen etwas anderen Satz von Zeichen, um die Zeichenfolge zu teilen, als die Trim(Char[]) Methode zum Kürzen der Zeichenfolge verwendet.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Beginnend mit dem .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Siehe auch

Split(Char, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichentrennlinie in Teilzeichenfolgen.Splits a string into substrings based on the provided character separator.

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.A character that delimits the substrings in this string.

options
StringSplitOptions

Einer der Enumerationswerte, der bestimmt, ob beim SPLIT-Vorgang leere Teilzeichenfolgen im Rückgabewert weggelassen werden sollen.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen von dieser Instanz enthält, die durch separator getrennt sind.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(String, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in Teilzeichenfolgen.Splits a string into substrings that are based on the provided string separator.

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.A string that delimits the substrings in this string.

options
StringSplitOptions

Einer der Enumerationswerte, der bestimmt, ob beim SPLIT-Vorgang leere Teilzeichenfolgen im Rückgabewert weggelassen werden sollen.One of the enumeration values that determines whether the split operation should omit empty substrings from the return value.

Gibt zurück

String[]

Ein Array, dessen Elemente die Teilzeichenfolgen von dieser Instanz enthält, die durch separator getrennt sind.An array whose elements contain the substrings from this instance that are delimited by separator.

Split(Char[])

Unterteilt eine Zeichenfolge anhand der Zeichen im Trennlinienarray in Teilzeichenfolgen.Splits a string into substrings that are based on the characters in the separator array.

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

Parameter

separator
Char[]

Ein Zeichenarray, das die Teilzeichenfolgen in dieser Zeichenfolge trennt, ein leeres Array ohne Trennzeichen oder null.A character array that delimits the substrings in this string, an empty array that contains no delimiters, or 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.An array whose elements contain the substrings from this instance that are delimited by one or more characters in separator. Weitere Informationen finden Sie im Abschnitt "Hinweise".For more information, see the Remarks section.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie einzelne Wörter aus einem Textblock extrahiert werden, indem Leerzeichen und Satzzeichen als Trennzeichen behandelt werden.The following example demonstrates how to extract individual words from a block of text by treating white space and punctuation marks as delimiters. Das Zeichen Array, das an den separator-Parameter der String.Split(Char[])-Methode übergeben wird, besteht aus einem Leerzeichen und einem Tabstopp Zeichen sowie einigen allgemeinen Interpunktions Symbolen.The character array passed to the separator parameter of the String.Split(Char[]) method consists of a space character and a tab character, together with some common punctuation symbols.

string words = "This is a list of words, with: a bit of punctuation" +
               "\tand a tab character.";

string [] split = words.Split(new Char [] {' ', ',', '.', ':', '\t' });

foreach (string s in split) 
{

    if (s.Trim() != "")
        Console.WriteLine(s);
}

// The example displays the following output to the console:
//       This
//       is
//       a
//       list
//       of
//       words
//       with
//       a
//       bit
//       of
//       punctuation
//       and
//       a
//       tab
//       character
Public Class SplitTest
    Public Shared Sub Main()
        Dim words As String = "This is a list of words, with: a bit of punctuation" + _
                              vbTab + "and a tab character."
        Dim split As String() = words.Split(New [Char]() {" "c, ","c, "."c, ":"c, CChar(vbTab) })
                
        For Each s As String In  split
            If s.Trim() <> "" Then
                Console.WriteLine(s)
            End If
        Next s
    End Sub
End Class
' The example displays the following output to the console:
'       This
'       is
'       a
'       list
'       of
'       words
'       with
'       a
'       bit
'       of
'       punctuation
'       and
'       a
'       tab
'       character

Hinweise

Wenn eine Zeichenfolge durch einen bekannten Zeichensatz begrenzt ist, können Sie die Split(Char[])-Methode verwenden, um Sie in Teil Zeichenfolgen zu trennen.When a string is delimited by a known set of characters, you can use the Split(Char[]) method to separate it into substrings.

Rückgabewert DetailsReturn value details

Trennzeichen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.Delimiter characters are not included in the elements of the returned array. Wenn das Trennzeichen Array z. b. das Zeichen "-" enthält und der Wert der aktuellen Zeichen folgen Instanz "AA-BB-CC" ist, gibt die Methode ein Array zurück, das drei Elemente enthält: "AA", "BB" und "CC".For example, if the separator array includes the character "-" and the value of the current string instance is "aa-bb-cc", the method returns an array that contains three elements: "aa", "bb", and "cc".

Wenn diese Instanz keines der Zeichen in separatorenthält, besteht das zurückgegebene Array aus einem einzelnen Element, das diese Instanz enthält.If this instance does not contain any of the characters in separator, the returned array consists of a single element that contains this instance.

Jedes Element von separator definiert ein separates Trennzeichen.Each element of separator defines a separate delimiter character. Wenn zwei Trennzeichen nebeneinander liegen oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Element im zurückgegebenen Array Empty.If two delimiters are adjacent, or a delimiter is found at the beginning or end of this instance, the corresponding element in the returned array contains Empty. Hier einige Beispiele:Here are some examples:

Zeichen folgen WertString value TrennzeichenSeparator Zurück gegebenes ArrayReturned array
"42, 12, 19""42, 12, 19" New Char [] {', ', ' '} (C#)new Char[] {',', ' '} (C#)

Char () = {"," c "," c} "(Visual Basic)Char() = {","c, " "c}) (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"42..12..19""42..12..19" new Char[] {'.'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
Bananen"Banana" new Char[] {'.'}new Char[] {'.'} (C#)(C#)

Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)
{"Banana"}{"Banana"}
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
New Char [] {} (C#)new Char[] {} (C#)

Char () = {} (Visual Basic)Char() = {} (Visual Basic)
{"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#)

"Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
null (C#)null (C#)

Nothing (Visual Basic)Nothing (Visual Basic)
{"Darb", "Smarba"}{"Darb", "Smarba"}

Das Trennzeichen ArrayThe separator array

Jedes Element des Trenn Zeichens definiert ein separates Trennzeichen, das aus einem einzelnen Zeichen besteht.Each element of separator defines a separate delimiter that consists of a single character. Wenn das separator-Argument null ist oder keine Zeichen enthält, behandelt die Methode Leerzeichen als Trennzeichen.If the separator argument is null or contains no characters, the method treats white-space characters as the delimiters. Leerzeichen werden durch den Unicode-Standard definiert. Sie geben true zurück, wenn Sie an die Char.IsWhiteSpace-Methode übermittelt werden.White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

String. Split (Char []) und compilerüberladungs AuflösungString.Split(Char[]) and compiler overload resolution

Obwohl der einzige Parameter für diese Überladung von String.Split ein Zeichen Array ist, können Sie es mit einem einzelnen Zeichen aufrufen, wie im folgenden Beispiel gezeigt.Although the single parameter for this overload of String.Split is a character array, you can call it with a single character, as the following example shows.

String value = "This is a short string.";
Char delimiter = 's';
String[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
   Console.WriteLine(substring);
// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.
Module Example
   Public Sub Main()
      Dim value As String = "This is a short string."
      Dim delimiter As Char = "s"c
      Dim substrings() As String = value.Split(delimiter)
      For Each substring In substrings
         Console.WriteLine(substring)
      Next
   End Sub
End Module
' The example displays the following output:
'     Thi
'      i
'      a
'     hort
'     tring.

Da der separator-Parameter mit dem ParamArrayAttribute-Attribut versehen ist, interpretieren Compiler ein einzelnes Zeichen als ein Zeichen Array mit einem einzelnen Element.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. Dies ist nicht der Fall für andere String.Split Überladungen, die einen separator-Parameter enthalten. Sie müssen diese Überladungen explizit als separator Argument übergeben.This is not the case for other String.Split overloads that include a separator parameter; you must explicitly pass these overloads a character array as the separator argument.

Vergleichs DetailsComparison details

Die Split(Char[])-Methode extrahiert die Teil Zeichenfolgen in dieser Zeichenfolge, die durch ein oder mehrere der Zeichen im separator Array getrennt sind, und gibt diese Teil Zeichenfolgen als Elemente eines Arrays zurück.The Split(Char[]) method extracts the substrings in this string that are delimited by one or more of the characters in the separator array, and returns those substrings as elements of an array.

Die Split(Char[])-Methode sucht nach Trennzeichen, indem Sie Vergleiche mithilfe von ordinalsortierungs Regeln für die Groß-und Kleinschreibung durchführtThe Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Weitere Informationen zu Wort-, Zeichen folgen-und ordinalsortierungen finden Sie in der System.Globalization.CompareOptions-Enumeration.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Überlegungen zur LeistungPerformance Considerations

Die Split-Methoden weisen Speicher für das zurückgegebene Array Objekt und ein String-Objekt für jedes Array Element zu.The Split methods allocate memory for the returned array object and a String object for each array element. Wenn Ihre Anwendung eine optimale Leistung erfordert oder wenn die Verwaltung der Speicher Belegung in Ihrer Anwendung wichtig ist, sollten Sie die IndexOf-oder IndexOfAny-Methode verwenden.If your application requires optimal performance or if managing memory allocation is critical in your application, consider using the IndexOf or IndexOfAny method. Sie haben auch die Möglichkeit, die Compare-Methode zu verwenden, um eine Teil Zeichenfolge innerhalb einer Zeichenfolge zu suchen.You also have the option of using the Compare method to locate a substring within a string.

Um eine Zeichenfolge mit einem Trennzeichen aufzuteilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um ein Trennzeichen in der Zeichenfolge zu suchen.To split a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Um eine Zeichenfolge in eine Trenn Zeichenfolge aufzuteilen, verwenden Sie die IndexOf-oder IndexOfAny-Methode, um das erste Zeichen der Trenn Zeichenfolge zu suchen.To split a string at a separator string, use the IndexOf or IndexOfAny method to locate the first character of the separator string. Verwenden Sie dann die Compare-Methode, um zu bestimmen, ob die Zeichen nach dem ersten Zeichen gleich den verbleibenden Zeichen der Trenn Zeichenfolge sind.Then use the Compare method to determine whether the characters after that first character are equal to the remaining characters of the separator string.

Wenn außerdem die gleichen Zeichen folgen zum Aufteilen von Zeichen folgen in mehreren Split Methoden aufrufen verwendet werden, sollten Sie in Erwägung gezogen werden, ein einzelnes Array zu erstellen und in jedem Methodenaufruf darauf zu verweisen.In addition, if the same set of characters is used to split strings in multiple Split method calls, consider creating a single array and referencing it in each method call. Dadurch wird der zusätzliche mehr Aufwand für die einzelnen Methodenaufrufe erheblich reduziert.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

Wenn in der .NET Framework 3,5.NET Framework 3.5 und früheren Versionen der Split(Char[])-Methode ein separator an null oder keine Zeichen enthält, verwendet die-Methode einen etwas anderen Satz von Zeichen, um die Zeichenfolge zu teilen, als die Trim(Char[]) Methode zum Kürzen der Zeichenfolge verwendet.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, if the Split(Char[]) method is passed a separator that is null or contains no characters, the method uses a slightly different set of characters to split the string than the Trim(Char[]) method does to trim the string. Beginnend mit dem .NET Framework 4 verwenden beide Methoden einen identischen Satz von Unicode-Leerzeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Siehe auch

Gilt für: