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

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

Gibt zurück

Ausnahmen

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.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
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.

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

Gibt zurück

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

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

Gibt zurück

Ausnahmen

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.

   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.

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 ist "-_aa -_", und der Wert von der options Argument ist None, die Methode gibt ein Zeichenfolgenarray mit 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 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.

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

Gibt zurück

Ausnahmen

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.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
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.

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

Gibt zurück

Ausnahmen

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.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] {','};
string[] stringSeparators = new string[] {"[stop]"};
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

' This example demonstrates the String() methods that use
' the StringSplitOptions enumeration.
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.

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

Gibt zurück

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.

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"	new Char[] {',', ' '} (C#)new Char[] {',', ' '} (C#) Char() = {","c, " "c} (Visual Basic)Char() = {","c, " "c} (Visual Basic)	22	{"42", " 12, 19"}{"42", " 12, 19"}
"42..12..19""42..12..19"	new Char[] {'.'}new Char[] {'.'} (C#)(C#) Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)	44	{"42", "", "12", ".19"}{"42", "", "12", ".19"}
"Banana""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

CharCharCharChar

Array

Int32Int32Int32Int32

Concat(Object)Concat(Object)Concat(Object)Concat(Object)

Insert(Int32, String)Insert(Int32, String)Insert(Int32, String)Insert(Int32, String)

Join(String, String[])Join(String, String[])Join(String, String[])Join(String, String[])

Remove(Int32, Int32)Remove(Int32, Int32)Remove(Int32, Int32)Remove(Int32, Int32)

Replace(Char, Char)Replace(Char, Char)Replace(Char, Char)Replace(Char, Char)

Substring(Int32)Substring(Int32)Substring(Int32)Substring(Int32)

Trim(Char[])Trim(Char[])Trim(Char[])Trim(Char[])

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

Gibt zurück

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

Gibt zurück

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.

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"	new Char[] {',', ' '} (C#)new Char[] {',', ' '} (C#) Char() = {","c, " "c}) (Visual Basic)Char() = {","c, " "c}) (Visual Basic)	{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"42..12..19""42..12..19"	new Char[] {'.'}new Char[] {'.'} (C#)(C#) Char() = {"."c} (Visual Basic)Char() = {"."c} (Visual Basic)	{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"Banana""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.

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

CharCharCharChar

Concat(Object)Concat(Object)Concat(Object)Concat(Object)

Insert(Int32, String)Insert(Int32, String)Insert(Int32, String)Insert(Int32, String)

Join(String, String[])Join(String, String[])Join(String, String[])Join(String, String[])

Remove(Int32, Int32)Remove(Int32, Int32)Remove(Int32, Int32)Remove(Int32, Int32)

Replace(Char, Char)Replace(Char, Char)Replace(Char, Char)Replace(Char, Char)

Substring(Int32)Substring(Int32)Substring(Int32)Substring(Int32)

Trim(Char[])Trim(Char[])Trim(Char[])Trim(Char[])

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