String.Split String.Split String.Split String.Split Method

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(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) 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, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) 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) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) 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(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen.Splits a string into substrings that are based on the characters in an array.

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) 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) Split(Char[], Int32) Split(Char[], Int32) 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) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)

Hinweise

Split wird verwendet, um eine durch Trennzeichen getrennte Zeichenfolge in Teilzeichenfolgen zu unterteilen.Split is used to break a delimited string into substrings. Sie können entweder ein Array von Zeichen an der 0 (null), einer oder mehrerer Trennzeichen verwenden (die Split(Char[]) Methode), oder Sie können ein Array von Zeichen an der 0 (null), einer oder mehrerer Trennzeichen-Zeichenfolgen.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. Überladungen der der Split Methode können Sie die Anzahl der Teilzeichenfolgen, die von der Methode zurückgegebenen zu beschränken (die Split(Char[], Int32) Methode), um zu bestimmen, ob leere Zeichenfolgen in der zurückgegebenen untergeordneten Zeichenfolgen enthalten sind (die Split(Char[], StringSplitOptions) und Split(String[], StringSplitOptions) Methoden oder beides (die Split(Char[], Int32, StringSplitOptions) und Split(String[], Int32, StringSplitOptions) Methoden).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 zur String.SplitAlternatives to String.Split

Die Split Methode ist nicht immer die beste Methode zum Unterbrechen einer durch Trennzeichen getrennte Zeichenfolge in Teilzeichenfolgen.The Split method is not always the best way to break a delimited string into substrings. Wenn nicht alle der Teilzeichenfolgen einer durch Trennzeichen getrennten Zeichenfolge extrahiert werden soll, oder wenn Sie eine Zeichenfolge, die basierend auf einem Muster, anstatt einen Satz von Trennzeichen analysieren möchten, sollten Sie die folgenden Alternativen.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 Zeichenfolgen mit einem festen Muster entsprechen, können Sie einen regulären Ausdruck zum Extrahieren und verarbeiten die Elemente.If your strings conform to a fixed pattern, you can use a regular expression to extract and handle their elements. Wenn Zeichenfolgen in Form werden z. B. "Anzahl Operanden Anzahl" können Sie eine reguläre extrahieren und Verarbeiten der Zeichenfolge-Elemente.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:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      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 (Match m in 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

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

MusterPattern Beschreibung Description
(\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+ Übereinstimmung mit ein oder mehrere Leerzeichen Zeichen.Match one or more white-space characters.
([-+*/]) Entspricht einem arithmetischen Operator Vorzeichen (+, -, *, oder /).Match an arithmetic operator sign (+, -, *, or /). Dies ist die zweite Erfassungsgruppe.This is the second capturing group.
\s+ Übereinstimmung mit ein oder mehrere Leerzeichen Zeichen.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 Teilzeichenfolgen aus einer Zeichenfolge basierend auf einen festen Satz von Zeichen, anstatt ein Muster 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 dieser Bedingungen auftritt:This is a common scenario when either of these conditions occurs:

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

  • Die Reihenfolge und Anzahl von Trennzeichen ist variabel oder unbekannt.The sequence and number of delimiter characters is variable or unknown.

Z. B. die Split Methode kann nicht zum Aufteilen der folgenden Zeichenfolge, nicht verwendet werden, da die Anzahl der \n (in c#) oder vbCrLf Zeichen ist die Variable (in Visual Basic), und sie 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.]  

Diese Zeichenfolge kann einfach, wie das folgende Beispiel zeigt ein regulärer Ausdruck aufgeteilt werden.A regular expression can split this string easily, as the following example shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      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 (Match m in 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.

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

MusterPattern Beschreibung Description
\[ Übereinstimmung mit eine öffnende eckige Klammer ein.Match an opening bracket.
([^\[\]]+) Übereinstimmung mit beliebigem Zeichen, das kein öffnendes oder eine schließende Klammer ist mindestens einmal aus.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.
\] Übereinstimmung mit einer schließenden Klammer ein.Match a closing bracket.

Die Regex.Split Methode ist fast identisch mit String.Split, außer dass es sich um eine Zeichenfolge, die basierend auf das Muster eines regulären Ausdrucks anstelle eines festen Zeichen unterteilt.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. Z. B. im folgenden Beispiel wird die Regex.Split Methode zum Aufteilen einer Zeichenfolge, die durch verschiedene Kombinationen von Bindestrichen und andere Zeichen getrennten Teilzeichenfolgen enthält.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.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      String input = "abacus -- alabaster - * - atrium -+- " +
                     "any -*- actual - + - armoir - - alarm";
      String pattern = @"\s-\s?[+*]?\s?-\s";
      String[] elements = Regex.Split(input, pattern);
      foreach (var element in elements)
         Console.WriteLine(element);
   }
}
// The example displays the following output:
//       abacus
//       alabaster
//       atrium
//       any
//       actual
//       armoir
//       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

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

MusterPattern Beschreibung Description
\s- Entspricht einem Leerstellenzeichen 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.
[+*]? Übereinstimmung mit keinem oder einem Vorkommen entweder das + oder * Zeichen.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 Übereinstimmung mit einem Bindestrich gefolgt von einem Leerzeichen.Match a hyphen followed by a white-space character.

Suchen von Methoden und der Substring-MethodeSearch methods and the Substring method

Wenn Sie nicht alle die Teilzeichenfolgen in einer Zeichenfolge interessiert sind, möchten Sie möglicherweise arbeiten mit einer der Methoden zum Zeichenfolgenvergleich, der den Index zurückgibt, an dem der Vergleich 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. Rufen Sie anschließend die Substring Methode, um die Teilzeichenfolge extrahiert, die Sie möchten.You can then call the Substring method to extract the substring that you want. Die Methoden zum Zeichenfolgenvergleich umfassen:The string comparison methods include:

  • IndexOf, den nullbasierten Index des ersten Vorkommens eines Zeichens oder einer Zeichenfolge in eine Zeichenfolgeninstanz zurückgegeben.IndexOf, which returns the zero-based index of the first occurrence of a character or string in a string instance.

  • IndexOfAny, die den nullbasierten Index in der aktuellen Zeichenfolgeninstanz des ersten Vorkommens eines beliebigen Zeichens aus einem Array von Zeichen 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, den nullbasierten Index des letzten Vorkommens eines Zeichens oder einer Zeichenfolge in eine Zeichenfolgeninstanz zurückgegeben.LastIndexOf, which returns the zero-based index of the last occurrence of a character or string in a string instance.

  • LastIndexOfAny, die einen nullbasierten Index in der aktuellen Zeichenfolgeninstanz des letzten Vorkommens eines beliebigen Zeichens aus einem Array von Zeichen 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, um die Punkte in einer Zeichenfolge gesucht.The following example uses the IndexOf method to find the periods in a string. Anschließend wird mithilfe der Substring Methode, um vollständige Sätze zurückzugeben.It then uses the Substring method to return full sentences.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) 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 Int32 Int32 Int32

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

options
StringSplitOptions StringSplitOptions StringSplitOptions 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.

Ausnahmen

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

Beispiele

Im folgenden Beispiel wird die StringSplitOptions Enumeration zum ein- bzw. Ausschließen von generierte Teilzeichenfolgen der Split Methode.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.
using System;

class Sample 
{
    public static void Main() 
    {
    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.
    public static 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.
Imports System

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 'Main
    
    
    ' 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 'Show
End Class 'Sample
'
'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-Zeichenfolgen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.Delimiter strings are not included in the elements of the returned array.

Wenn keine der Zeichenfolgen in dieser Instanz enthält separator, oder die count Parameter ist 1, das zurückgegebene Array besteht 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 die separator Parameter null oder keine Zeichen enthält, Leerzeichen werden als Trennzeichen angesehen.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch die Unicode-standard und return definiert true Wenn es sich bei der Übergabe an die Char.IsWhiteSpace Methode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Aber wenn die separator Parameter im Aufruf an die Überladung dieser Methode ist null, überladungsauflösung des Compiler ein Fehler auftritt.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Um die aufgerufene Methode eindeutig identifizieren zu können, muss Ihr Code Geben Sie den Typ des der null.To unambiguously identify the called method, your code must indicate the type of the null. Das folgende Beispiel zeigt mehrere Möglichkeiten, diese Überladung eindeutig zu identifizieren.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 die count Parameter NULL ist, oder die options Parameter RemoveEmptyEntries und die Länge dieser Instanz ist 0 (null), 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 der separator definiert ein separates Trennzeichen, das ein oder mehrere Zeichen besteht.Each element of separator defines a separate delimiter that consists of one or more characters. Wenn die options Parameter None, und zwei Trennzeichen benachbarten oder am Anfang oder Ende dieser Instanz ein einzeln verwendetes Trennzeichen gefunden wird, enthält das entsprechende Arrayelement 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.

Treten mehr als count Teilzeichenfolgen in dieser Instanz, die die erste count -1 Teilzeichenfolgen werden in der ersten zurückgegeben count minus 1 Elemente zurückgegeben, und die restlichen Zeichen in dieser Instanz werden in den letzten zurückgegeben Element des Rückgabewerts.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 ist größer als die Anzahl von Teilzeichenfolgen auf, werden die verfügbaren Teilzeichenfolgen zurückgegeben und keine Ausnahme ausgelöst wird.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Das Separator-arrayThe separator array

Wenn eines der Elemente im separator besteht aus mehreren Zeichen, wird die gesamte Teilzeichenfolge als ein Trennzeichen betrachtet.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Angenommen, eine der Elemente im separator ist "10", es wird versucht, teilen die Zeichenfolge "This10is10a10string."For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." Dieses Array mit vier Elementen zurückgegeben: {"This", "ist", "a", "String".returns this four-element array: { "This", "is", "a", "string." }.}.

Von VergleichsdetailsComparison details

Die Split -Methode extrahiert die Teilzeichenfolgen in dieser Zeichenfolge, die durch mindestens eine der Zeichenfolgen in getrennten der separator -Parameter und gibt diese Teilzeichenfolgen 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 durch Durchführen von Vergleichen mit der Groß-/Kleinschreibung der ordinalen Sortierregeln.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Weitere Informationen über Wort-, Zeichenfolgen- und ordinal sortiert, finden Sie unter den System.Globalization.CompareOptions Enumeration.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Die Split Methode ignoriert alle Elemente von separator , dessen Wert null oder eine leere Zeichenfolge ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Um mehrdeutige Ergebnisse zu vermeiden bei Zeichenfolgen im separator haben Zeichen gemeinsam, die Split Methode wird vom Anfang bis zum Ende des Werts der Instanz, und entspricht dem ersten Element in separator gleich ein Trennzeichen in der -Instanz.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 dem Teilzeichenfolgen in der Instanz, hat Vorrang vor der Reihenfolge der Elemente im separator.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Betrachten Sie beispielsweise eine Instanz, deren Wert "Abcdef".For example, consider an instance whose value is "abcdef". Wenn das erste Element im separator wurde von "Ef" und das zweite Element "bcde", das Ergebnis des Split-Vorgangs wäre "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". Grund hierfür ist die Teilzeichenfolge in der Instanz "bcde" überein, festgestellt wird, und entspricht einem Element im separator vor die Teilzeichenfolge "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.

Aber wenn das erste Element der separator wurde, wurde "bc", "bcd" und das zweite Element, das Ergebnis des Split-Vorgangs wäre "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" and "ef". Dies liegt daran "bcd" das erste Trennzeichen in separator , die ein Trennzeichen in der Instanz entspricht.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Wenn die Reihenfolge der Trennzeichen umgekehrt wird, sodass das erste Element "bc" wurde und das zweite Element wurde "bcd", das Ergebnis wäre "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 von Arbeitsspeicher für das zurückgegebene Arrayobjekt und String -Objekt für jedes Arrayelement.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 von speicherbelegung in Ihre Anwendung von entscheidender Bedeutung ist, sollten Sie die IndexOf oder IndexOfAny -Methode, und optional die Compare Methode, eine Teilzeichenfolge innerhalb einer Zeichenfolge 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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen eines Trennzeichens in der Zeichenfolge.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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen des ersten Zeichens der Zeichenfolge als Trennzeichen.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 der verbleibenden Zeichen in der Trennzeichenfolge gleich 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.

Darüber hinaus, wenn der gleiche Satz von Zeichen wird verwendet, um Zeichenfolgen in mehreren Teilen Split Methodenaufrufe, sollten Sie ein einzelnes Array erstellen, und klicken Sie in jedem Methodenaufruf darauf 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 erheblich reduziert, der zusätzliche Verarbeitungsaufwand von jedem Methodenaufruf.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

In der .NET Framework 3,5.NET Framework 3.5 und frühere Versionen, wenn die Split(Char[]) -Methode übergeben eine separator , null oder keine Zeichen enthält, die Methode verwendet einen etwas anderen Satz von Zeichen zum Aufteilen der Zeichenfolge als die Trim(Char[]) Methode führt zu Verringern Sie die Zeichenfolge ein.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. Ab .NET Framework 4, verwenden beide Methoden einen identischen Satz von Unicode-Zeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)

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

Gibt zurück

String[]

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) 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 Int32 Int32 Int32

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

options
StringSplitOptions StringSplitOptions StringSplitOptions 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.

Ausnahmen

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

Beispiele

Im folgenden Beispiel wird die StringSplitOptions Enumeration zum ein- bzw. Ausschließen von generierte Teilzeichenfolgen der Split Methode.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.
using System;

class Sample 
{
    public static void Main() 
    {
    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.
    public static 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.
Imports System

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 'Main
    
    
    ' 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 'Show
End Class 'Sample
'
'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 keine Zeichen enthält separator, oder die count Parameter ist 1, das zurückgegebene Array besteht 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 die separator Parameter null oder keine Zeichen enthält, Leerzeichen werden als Trennzeichen angesehen.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch die Unicode-standard und return definiert true Wenn es sich bei der Übergabe an die Char.IsWhiteSpace Methode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method. Aber wenn die separator Parameter im Aufruf an die Überladung dieser Methode ist null, überladungsauflösung des Compiler ein Fehler auftritt.However, if the separator parameter in the call to this method overload is null, compiler overload resolution fails. Um die aufgerufene Methode eindeutig identifizieren zu können, muss Ihr Code den Typ der Null angeben.To unambiguously identify the called method, your code must indicate the type of the null. Das folgende Beispiel zeigt mehrere Möglichkeiten, diese Überladung eindeutig zu identifizieren.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 die count Parameter NULL ist, oder die options Parameter RemoveEmptyEntries und die Länge dieser Instanz ist 0 (null), 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 der separator ein separates Trennzeichen definiert.Each element of separator defines a separate delimiter character. Wenn die options Parameter None, und zwei Trennzeichen benachbarten oder am Anfang oder Ende dieser Instanz ein einzeln verwendetes Trennzeichen gefunden wird, enthält das entsprechende Arrayelement 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.

Treten mehr als count Teilzeichenfolgen in dieser Instanz, die die erste count -1 Teilzeichenfolgen werden in der ersten zurückgegeben count minus 1 Elemente zurückgegeben, und die restlichen Zeichen in dieser Instanz werden in den letzten zurückgegeben Element des Rückgabewerts.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 ist größer als die Anzahl von Teilzeichenfolgen auf, werden die verfügbaren Teilzeichenfolgen zurückgegeben und keine Ausnahme ausgelöst wird.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 von Arbeitsspeicher für das zurückgegebene Arrayobjekt und String -Objekt für jedes Arrayelement.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 von speicherbelegung in Ihre Anwendung von entscheidender Bedeutung ist, sollten Sie die IndexOf oder IndexOfAny -Methode, und optional die Compare Methode, eine Teilzeichenfolge innerhalb einer Zeichenfolge 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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen eines Trennzeichens in der Zeichenfolge.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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen des ersten Zeichens der Zeichenfolge als Trennzeichen.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 der verbleibenden Zeichen in der Trennzeichenfolge gleich 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.

Darüber hinaus, wenn der gleiche Satz von Zeichen wird verwendet, um Zeichenfolgen in mehreren Teilen Split Methodenaufrufe, sollten Sie ein einzelnes Array erstellen, und klicken Sie in jedem Methodenaufruf darauf 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 erheblich reduziert, der zusätzliche Verarbeitungsaufwand von jedem Methodenaufruf.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

In der .NET Framework 3,5.NET Framework 3.5 und frühere Versionen, wenn die Split(Char[]) -Methode übergeben eine separator , null oder keine Zeichen enthält, die Methode verwendet einen etwas anderen Satz von Zeichen zum Aufteilen der Zeichenfolge als die Trim(Char[]) Methode führt zu Verringern Sie die Zeichenfolge ein.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. Ab .NET Framework 4, verwenden beide Methoden einen identischen Satz von Unicode-Zeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)

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 Char Char Char

Gibt zurück

String[]

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) 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 StringSplitOptions StringSplitOptions 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.

Ausnahmen

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

Beispiele

Das folgende Beispiel veranschaulicht den Unterschied in den Arrays zurückgegeben, indem einer Zeichenfolge String.Split(String[], StringSplitOptions) -Methode mit der options Parameter gleich StringSplitOptions.None und StringSplitOptions.RemoveEmptyEntries.The following example illustrates the difference in the arrays returned by calling a string's String.Split(String[], StringSplitOptions) method with its options parameter equal to StringSplitOptions.None and StringSplitOptions.RemoveEmptyEntries.

using System;

class Example 
{
   public static void Main() 
   {
      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'

Das folgende Beispiel definiert ein Array von Trennzeichen, die Interpunktion und Leerzeichen enthalten.The following example defines an array of separators that include punctuation and white-space characters. Übergeben dieses Array zusammen mit einem Wert von StringSplitOptions.RemoveEmptyEntries auf die Split(String[], StringSplitOptions) -Methode gibt ein Array, das die einzelnen Wörter, 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.

using System;

public class Example
{
   public static void Main()
   {
      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, die die Methode aufgerufen wird, mit der options Argument festgelegt wird, um StringSplitOptions.RemoveEmptyEntries.Note that the method is called with the options argument set to StringSplitOptions.RemoveEmptyEntries. Dadurch wird verhindert, dass das zurückgegebene Array einschließlich String.Empty Werten, leeren Teilzeichenfolge Übereinstimmungen zwischen Satzzeichen 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, die von einem bekannten Satz von Zeichenfolgen getrennt sind, können Sie die Split Methode für die Trennung in Teilzeichenfolgen.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-Zeichenfolgen sind nicht in den Elementen des zurückgegebenen Arrays enthalten.Delimiter strings are not included in the elements of the returned array. Z. B. wenn die separator Array enthält die Zeichenfolge "--" und der Wert der aktuellen Zeichenfolgeninstanz "aa - bb-cc", die Methode gibt ein Array, 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 keine der Zeichenfolgen in dieser Instanz enthält separator, das zurückgegebene Array besteht 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 die options Parameter RemoveEmptyEntries und die Länge dieser Instanz ist 0 (null), 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 der separator definiert ein separates Trennzeichen, das ein oder mehrere Zeichen besteht.Each element of separator defines a separate delimiter that consists of one or more characters. Wenn die options Argument None, und zwei Trennzeichen benachbarten oder am Anfang oder Ende dieser Instanz ein einzeln verwendetes Trennzeichen gefunden wird, enthält das entsprechende Arrayelement 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. Z. B. wenn separator enthält zwei Elemente, die "-" und "", der Wert der Zeichenfolgeninstanz "- _aa -\", und der Wert von der options Argument ist None, die Methode gibt ein Zeichenfolgenarray mit den folgenden fünf Elementen: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, steht für die leere Zeichenfolge, die vor der "-" Teilzeichenfolge am Index 0.String.Empty, which represents the empty string that precedes the "-" substring at index 0.

  2. String.Empty, steht für die leere Zeichenfolge zwischen den "-" Teilzeichenfolge am Index 0 und die Teilzeichenfolge "" am Index 1.String.Empty, which represents the empty string between the "-" substring at index 0 and the "" substring at index 1.

  3. "aa","aa",

  4. String.Empty, steht für die leere Zeichenfolge, die die Teilzeichenfolge "" am Index 4 folgt.String.Empty, which represents the empty string that follows the "" substring at index 4.

  5. String.Empty, steht für die leere Zeichenfolge, die folgt der "-" Teilzeichenfolge am Index 5.String.Empty, which represents the empty string that follows the "-" substring at index 5.

Das Separator-arrayThe separator array

Wenn eines der Elemente im separator besteht aus mehreren Zeichen, wird die gesamte Teilzeichenfolge als ein Trennzeichen betrachtet.If any of the elements in separator consists of multiple characters, the entire substring is considered a delimiter. Angenommen, eine der Elemente im separator ist "10", es wird versucht, teilen die Zeichenfolge "This10is10a10string."For example, if one of the elements in separator is "10", attempting to split the string "This10is10a10string." Gibt das folgende Array mit vier Elementen: {"This", "ist", "a", "String".returns the following four-element array: { "This", "is", "a", "string." }.}.

Wenn die separator Parameter null oder keine Zeichen enthält, Leerzeichen werden als Trennzeichen angesehen.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch die Unicode-standard und return definiert true Wenn es sich bei der Übergabe an die Char.IsWhiteSpace Methode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Wenn die separator Parameter im Aufruf an die Überladung dieser Methode ist null, überladungsauflösung des Compiler ein Fehler auftritt.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Um die aufgerufene Methode eindeutig identifizieren zu können, muss Ihr Code Geben Sie den Typ des der null.To unambiguously identify the called method, your code must indicate the type of the null. Das folgende Beispiel zeigt mehrere Möglichkeiten, diese Überladung eindeutig zu identifizieren.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)

Von VergleichsdetailsComparison details

Die Split -Methode extrahiert die Teilzeichenfolgen in dieser Zeichenfolge, die durch mindestens eine der Zeichenfolgen in getrennten der separator -Parameter und gibt diese Teilzeichenfolgen 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 durch Durchführen von Vergleichen mit der Groß-/Kleinschreibung der ordinalen Sortierregeln.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Weitere Informationen über Wort-, Zeichenfolgen- und ordinal sortiert, finden Sie unter den System.Globalization.CompareOptions Enumeration.For more information about word, string, and ordinal sorts, see the System.Globalization.CompareOptions enumeration.

Die Split Methode ignoriert alle Elemente von separator , dessen Wert null oder eine leere Zeichenfolge ("").The Split method ignores any element of separator whose value is null or the empty string ("").

Um mehrdeutige Ergebnisse zu vermeiden bei Zeichenfolgen im separator haben Zeichen gemeinsam, die Split Vorgang fortgesetzt wird vom Anfang bis zum Ende des Werts der Instanz, und entspricht dem ersten Element in separator gleich ein Trennzeichen in der -Instanz.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 dem Teilzeichenfolgen in der Instanz, hat Vorrang vor der Reihenfolge der Elemente im separator.The order in which substrings are encountered in the instance takes precedence over the order of elements in separator.

Betrachten Sie beispielsweise eine Instanz, deren Wert "Abcdef".For example, consider an instance whose value is "abcdef". Wenn das erste Element im separator wurde von "Ef" und das zweite Element "bcde", das Ergebnis des Split-Vorgangs wäre ein Zeichenfolgenarray, 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". Grund hierfür ist die Teilzeichenfolge in der Instanz "bcde" überein, festgestellt wird, und entspricht einem Element im separator vor die Teilzeichenfolge "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.

Aber wenn das erste Element der separator wurde, wurde "bc", "bcd" und das zweite Element, das Ergebnis des Split-Vorgangs wäre ein Zeichenfolgenarray, 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 "bcd" das erste Trennzeichen in separator , die ein Trennzeichen in der Instanz entspricht.This is because "bcd" is the first delimiter in separator that matches a delimiter in the instance. Wenn die Reihenfolge der Trennzeichen umgekehrt wird, sodass das erste Element "bc" wurde und das zweite Element wurde "bcd", das Ergebnis wäre ein Zeichenfolgenarray, 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 von Arbeitsspeicher für das zurückgegebene Arrayobjekt und String -Objekt für jedes Arrayelement.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 von speicherbelegung in Ihre Anwendung von entscheidender Bedeutung ist, sollten Sie die IndexOf oder IndexOfAny -Methode, und optional die Compare Methode, eine Teilzeichenfolge innerhalb einer Zeichenfolge 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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen eines Trennzeichens in der Zeichenfolge.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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen des ersten Zeichens der Zeichenfolge als Trennzeichen.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 der verbleibenden Zeichen in der Trennzeichenfolge gleich 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.

Darüber hinaus, wenn der gleiche Satz von Zeichen wird verwendet, um Zeichenfolgen in mehreren Teilen Split Methodenaufrufe, sollten Sie ein einzelnes Array erstellen, und klicken Sie in jedem Methodenaufruf darauf 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 erheblich reduziert, der zusätzliche Verarbeitungsaufwand von jedem Methodenaufruf.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

In der .NET Framework 3,5.NET Framework 3.5 und frühere Versionen, wenn die Split(Char[]) -Methode übergeben eine separator , null oder keine Zeichen enthält, die Methode verwendet einen etwas anderen Satz von Zeichen zum Aufteilen der Zeichenfolge als die Trim(Char[]) Methode führt zu Verringern Sie die Zeichenfolge ein.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. Ab .NET Framework 4, verwenden beide Methoden einen identischen Satz von Unicode-Zeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen.Splits a string into substrings that are based on the characters in an 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 um einzelne Wörter aus einen Textblock zu extrahieren, indem Sie zum Behandeln von Leerzeichen und Satzzeichen als Trennzeichen verwendet wird.The following example demonstrates how to extract individual words from a block of text by treating white space and punctuation marks as delimiters. Das Zeichenarray übergeben, um die separator Parameter, der die String.Split(Char[]) Methode besteht aus einem Leerzeichen und einem Tabstoppzeichen, zusammen mit einigen häufig verwendeten Interpunktionszeichen.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.

using System;

public class SplitTest {
    public static void Main() {

        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 'Main
End Class 'SplitTest
' 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 von einem bekannten Satz von Zeichen getrennt sind, können Sie die Split(Char[]) Methode für die Trennung in Teilzeichenfolgen.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 Array als Trennzeichen das Zeichen enthält z. B. "-" und der Wert der aktuellen Zeichenfolgeninstanz "aa-bb-cc", die Methode gibt ein Array, 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 keine Zeichen enthält separator, das zurückgegebene Array besteht 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 der separator ein separates Trennzeichen definiert.Each element of separator defines a separate delimiter character. Wenn zwei Trennzeichen benachbart sind 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:

ZeichenfolgenwertString value TrennzeichenSeparator Zurückgegebene arrayReturned array
"42, 12, 19""42, 12, 19" neue 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"}
"Banane""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)
neue 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 Separator-arrayThe separator array

Jedes Element des Trennzeichens definiert ein separates Trennzeichen, das ein einzelnes Zeichen besteht.Each element of separator defines a separate delimiter that consists of a single character. Wenn die separator Argument null oder keine Zeichen enthält, die Methode behandelt 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 die Unicode-standard definiert. Geben sie zurück true Wenn es sich bei der Übergabe an die Char.IsWhiteSpace Methode.White-space characters are defined by the Unicode standard; they return true if they are passed to the Char.IsWhiteSpace method.

Auflösen der Überladung String.Split(Char[]) und compilerString.Split(Char[]) and compiler overload resolution

Obwohl die einzelnen Parameter für diese Überladung der String.Split ist ein Array von Zeichen, können Sie ihn mit einem einzelnen Zeichen, wie im folgenden Beispiel gezeigt aufrufen.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.

using System;

public class Example
{
   public static void Main()
   {
      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 die separator Parameter versehen ist, mit der ParamArrayAttribute Attribut Compiler ein einzelnes Zeichen als ein Array von einem Element Zeichen interpretiert werden.Because the separator parameter is decorated with the ParamArrayAttribute attribute, compilers will interpret a single character as a single-element character array. Dies gilt nicht für andere String.Split Überladungen, die eine separator -Parameter müssen Sie explizit übergeben diese Überladungen ein Array von Zeichen als die separator Argument.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.

Von VergleichsdetailsComparison details

Die Split(Char[]) Methode extrahiert die Teilzeichenfolgen in dieser Zeichenfolge, die von einer oder mehreren Zeichen getrennt sind die separator array und gibt diese Teilzeichenfolgen 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 durch Durchführen von Vergleichen mit der Groß-/Kleinschreibung der ordinalen Sortierregeln.The Split(Char[]) method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Weitere Informationen über Wort-, Zeichenfolgen- und ordinal sortiert, finden Sie unter den 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 von Arbeitsspeicher für das zurückgegebene Arrayobjekt und String -Objekt für jedes Arrayelement.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 von speicherbelegung in Ihre Anwendung von entscheidender Bedeutung ist, sollten Sie die IndexOf oder IndexOfAny Methode.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 der Verwendung der Compare Methode, um eine Teilzeichenfolge innerhalb einer Zeichenfolge suchen.You also have the option of using the Compare method to locate a substring within a string.

Verwenden Sie zum Aufteilen einer Zeichenfolge am Trennzeichen der IndexOf oder IndexOfAny Methode zum Suchen eines Trennzeichens in der Zeichenfolge.To split a string at a separator character, use the IndexOf or IndexOfAny method to locate a separator character in the string. Verwenden Sie zum Aufteilen einer Zeichenfolge an einem Trennzeichen der IndexOf oder IndexOfAny Methode zum Suchen des ersten Zeichens der Zeichenfolge als Trennzeichen.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 der verbleibenden Zeichen in der Trennzeichenfolge gleich 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.

Darüber hinaus, wenn der gleiche Satz von Zeichen wird verwendet, um Zeichenfolgen in mehreren Teilen Split Methodenaufrufe, sollten Sie ein einzelnes Array erstellen, und klicken Sie in jedem Methodenaufruf darauf 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 erheblich reduziert, der zusätzliche Verarbeitungsaufwand von jedem Methodenaufruf.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

In der .NET Framework 3,5.NET Framework 3.5 und frühere Versionen, wenn die Split(Char[]) -Methode übergeben eine separator , null oder keine Zeichen enthält, die Methode verwendet einen etwas anderen Satz von Zeichen zum Aufteilen der Zeichenfolge als die Trim(Char[]) Methode führt zu Verringern Sie die Zeichenfolge ein.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. Ab .NET Framework 4, verwenden beide Methoden einen identischen Satz von Unicode-Zeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Siehe auch

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) 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 StringSplitOptions StringSplitOptions 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.

Ausnahmen

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

Beispiele

Im folgenden Beispiel wird die StringSplitOptions Enumeration zum ein- bzw. Ausschließen von generierte Teilzeichenfolgen der Split Methode.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.
using System;

class Sample 
{
    public static void Main() 
    {
    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.
    public static 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.
Imports System

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 'Main
    
    
    ' 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 'Show
End Class 'Sample
'
'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 in der 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. Z. B. wenn die separator Array enthält das Zeichen "-" und der Wert der aktuellen Zeichenfolgeninstanz "aa-bb-cc", die Methode gibt ein Array, 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 keine Zeichen enthält separator, das zurückgegebene Array besteht 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 die options Parameter RemoveEmptyEntries und die Länge dieser Instanz ist 0 (null), 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 der separator definiert ein separates Trennzeichen, das ein einzelnes Zeichen besteht.Each element of separator defines a separate delimiter that consists of a single character. Wenn die options Argument None, und zwei Trennzeichen benachbarten oder am Anfang oder Ende dieser Instanz ein einzeln verwendetes Trennzeichen gefunden wird, enthält das entsprechende Arrayelement 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. Z. B. wenn separator enthält zwei Elemente, die "-" und "_", ist der Wert der Zeichenfolgeninstanz "-_aa -_", und der Wert des der options Argument ist None, die Methode gibt ein Zeichenfolgenarray mit zurück. die folgenden fünf Elemente: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, steht für die leere Zeichenfolge, die vor der "-"-Zeichen am Index 0.String.Empty, which represents the empty string that precedes the "-" character at index 0.

  2. String.Empty, steht für die leere Zeichenfolge zwischen den "-"-Zeichen am Index 0 und das Zeichen "" am Index 1.String.Empty, which represents the empty string between the "-" character at index 0 and the "" character at index 1.

  3. "aa","aa",

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

  5. String.Empty, steht für die leere Zeichenfolge, die folgt der "-"-Zeichen am Index 5.String.Empty, which represents the empty string that follows the "-" character at index 5.

Das Separator-arrayThe separator array

Wenn die separator Parameter null oder keine Zeichen enthält, Leerzeichen werden als Trennzeichen angesehen.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch die Unicode-standard und return definiert true Wenn es sich bei der Übergabe an die Char.IsWhiteSpace Methode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Wenn die separator Parameter im Aufruf an die Überladung dieser Methode ist null, überladungsauflösung des Compiler ein Fehler auftritt.If the separator parameter in the call to this method overload is null, compiler overload resolution fails. Um die aufgerufene Methode eindeutig identifizieren zu können, muss Ihr Code Geben Sie den Typ des der null.To unambiguously identify the called method, your code must indicate the type of the null. Das folgende Beispiel zeigt mehrere Möglichkeiten, diese Überladung eindeutig zu identifizieren.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)

Von VergleichsdetailsComparison details

Die Split Methode extrahiert die Teilzeichenfolgen in dieser Zeichenfolge, die von einer oder mehreren Zeichen getrennt sind die separator -Parameter und gibt diese Teilzeichenfolgen 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 durch Durchführen von Vergleichen mit der Groß-/Kleinschreibung der ordinalen Sortierregeln.The Split method looks for delimiters by performing comparisons using case-sensitive ordinal sort rules. Weitere Informationen über Wort-, Zeichenfolgen- und ordinal sortiert, finden Sie unter den 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 von Arbeitsspeicher für das zurückgegebene Arrayobjekt und String -Objekt für jedes Arrayelement.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 von speicherbelegung in Ihre Anwendung von entscheidender Bedeutung ist, sollten Sie die IndexOf oder IndexOfAny -Methode, und optional die Compare Methode, eine Teilzeichenfolge innerhalb einer Zeichenfolge 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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen eines Trennzeichens in der Zeichenfolge.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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen des ersten Zeichens der Zeichenfolge als Trennzeichen.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 der verbleibenden Zeichen in der Trennzeichenfolge gleich 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.

Darüber hinaus, wenn der gleiche Satz von Zeichen wird verwendet, um Zeichenfolgen in mehreren Teilen Split Methodenaufrufe, sollten Sie ein einzelnes Array erstellen, und klicken Sie in jedem Methodenaufruf darauf 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 erheblich reduziert, der zusätzliche Verarbeitungsaufwand von jedem Methodenaufruf.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

In der .NET Framework 3,5.NET Framework 3.5 und frühere Versionen, wenn die Split(Char[]) -Methode übergeben eine separator , null oder keine Zeichen enthält, die Methode verwendet einen etwas anderen Satz von Zeichen zum Aufteilen der Zeichenfolge als die Trim(Char[]) Methode führt zu Verringern Sie die Zeichenfolge ein.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. Ab .NET Framework 4, verwenden beide Methoden einen identischen Satz von Unicode-Zeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) 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 Int32 Int32 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

Beispiele

Im folgende Beispiel wird veranschaulicht, wie count wirkt sich auf die Anzahl der Zeichenfolgen, die vom Split.The following example demonstrates how count affects the number of strings returned by Split.

using System;

public class Example
{
   public static void Main() 
   {
      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 keine Zeichen enthält separator, das zurückgegebene Array besteht 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 die separator Parameter null oder keine Zeichen enthält, Leerzeichen werden als Trennzeichen angesehen.If the separator parameter is null or contains no characters, white-space characters are assumed to be the delimiters. Leerzeichen werden durch die Unicode-standard und return definiert true Wenn es sich bei der Übergabe an die Char.IsWhiteSpace Methode.White-space characters are defined by the Unicode standard and return true if they are passed to the Char.IsWhiteSpace method.

Jedes Element der separator ein separates Trennzeichen definiert.Each element of separator defines a separate delimiter character. Wenn zwei Trennzeichen benachbart sind oder ein Trennzeichen am Anfang oder Ende dieser Instanz gefunden wird, enthält das entsprechende Arrayelement 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.

Treten mehr als count Teilzeichenfolgen in dieser Instanz, die die erste count -1 Teilzeichenfolgen werden in der ersten zurückgegeben count minus 1 Elemente zurückgegeben, und die restlichen Zeichen in dieser Instanz werden in den letzten zurückgegeben Element des Rückgabewerts.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 ist größer als die Anzahl von Teilzeichenfolgen auf, werden die verfügbaren Teilzeichenfolgen zurückgegeben und keine Ausnahme ausgelöst wird.If count is greater than the number of substrings, the available substrings are returned and no exception is thrown.

Die folgende Tabelle enthält Beispiele.The following table provides examples.

ZeichenfolgenwertString value TrennzeichenSeparator AnzahlCount Zurückgegebene arrayReturned array
"42, 12, 19""42, 12, 19" neue 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"}
"Banane""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)
neue 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)
neue 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)
neue Char [] null (C#)new Char[] null (C#)

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

Überlegungen zur LeistungPerformance Considerations

Die Split Methoden von Arbeitsspeicher für das zurückgegebene Arrayobjekt und String -Objekt für jedes Arrayelement.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 von speicherbelegung in Ihre Anwendung von entscheidender Bedeutung ist, sollten Sie die IndexOf oder IndexOfAny -Methode, und optional die Compare Methode, eine Teilzeichenfolge innerhalb einer Zeichenfolge 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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen eines Trennzeichens in der Zeichenfolge.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 an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen des ersten Zeichens der Zeichenfolge als Trennzeichen.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 der verbleibenden Zeichen in der Trennzeichenfolge gleich 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.

Darüber hinaus, wenn der gleiche Satz von Zeichen wird verwendet, um Zeichenfolgen in mehreren Teilen Split Methodenaufrufe, sollten Sie ein einzelnes Array erstellen, und klicken Sie in jedem Methodenaufruf darauf 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 erheblich reduziert, der zusätzliche Verarbeitungsaufwand von jedem Methodenaufruf.This significantly reduces the additional overhead of each method call.

Hinweise für Aufrufer

In der .NET Framework 3,5.NET Framework 3.5 und frühere Versionen, wenn die Split(Char[]) -Methode übergeben eine separator , null oder keine Zeichen enthält, die Methode verwendet einen etwas anderen Satz von Zeichen zum Aufteilen der Zeichenfolge als die Trim(Char[]) Methode führt zu Verringern Sie die Zeichenfolge ein.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. Ab .NET Framework 4, verwenden beide Methoden einen identischen Satz von Unicode-Zeichen.Starting with the .NET Framework 4, both methods use an identical set of Unicode white-space characters.

Siehe auch

Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)

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 Char Char Char

Gibt zurück

String[]

Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)

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

Gibt zurück

String[]

Gilt für: