String.Split Methode

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

Attribute

ComVisibleAttribute

Ausnahmen

Beispiele

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

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

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

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

/*
This example produces the following results:

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

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

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

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

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

*/

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

Hinweise

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

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

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

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

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

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

Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

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

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

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

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

Überlegungen zur LeistungPerformance Considerations

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

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

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

Hinweise für Aufrufer

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

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

public string[] Split (char separator, int count, StringSplitOptions options = System.StringSplitOptions.None);

member this.Split : char * int * StringSplitOptions -> string[]

Public Function Split (separator As Char, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parameter

Gibt zurück

Hinweise

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

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

Attribute

ComVisibleAttribute

Ausnahmen

Beispiele

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

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

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

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

/*
This example produces the following results:

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

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

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

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

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

*/

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

Hinweise

Rückgabewert DetailsReturn value details

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

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

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

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

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

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

Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

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

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

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

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

Das Trennzeichen ArrayThe separator array

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

Vergleichs DetailsComparison details

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

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

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

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

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

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

Überlegungen zur LeistungPerformance considerations

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

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

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

Hinweise für Aufrufer

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

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

Attribute

ComVisibleAttribute

Ausnahmen

Beispiele

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

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

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

   // The example displays the following output:
   //    Splitting the string:
   //       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
   //    
   //    Using the delimiter string:
   //       "[stop]"
   //    
   //    Result including all elements (9 elements):
   //       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
   //    
   //    Result including non-empty elements (3 elements):
   //       'ONE' 'TWO' 'THREE'

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

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

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

string[] separators = {",", ".", "!", "?", ";", ":", " "};
string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in words)
   Console.WriteLine(word);
   
// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate

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

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

Hinweise

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

Rückgabewert DetailsReturn value details

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

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

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

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

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

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

3. "aa","aa",

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

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

Das Trennzeichen ArrayThe separator array

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

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

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

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

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

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

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

Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

Vergleichs DetailsComparison details

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

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

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

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

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

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

Überlegungen zur LeistungPerformance considerations

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

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

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

Hinweise für Aufrufer

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

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

public string[] Split (string separator, int count, StringSplitOptions options = System.StringSplitOptions.None);

member this.Split : string * int * StringSplitOptions -> string[]

Public Function Split (separator As String, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parameter

Gibt zurück

Hinweise

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

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

Attribute

ComVisibleAttribute

Ausnahmen

Beispiele

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

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

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

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

/*
This example produces the following results:

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

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

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

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

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

*/

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
This example produces the following results:

1) Split a string delimited by characters:

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

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

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

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

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

2) Split a string delimited by another string:

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

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

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

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

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

*/

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

Hinweise

Rückgabewert DetailsReturn value details

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

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

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

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

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

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

3. "aa","aa",

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

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

Das Trennzeichen ArrayThe separator array

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

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

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

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

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

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

Dim phrase As String = "The quick brown fox"
Dim words() As String

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

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

Vergleichs DetailsComparison details

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

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

Überlegungen zur LeistungPerformance Considerations

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

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

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

Hinweise für Aufrufer

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

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 folgenden Beispiel wird veranschaulicht, wie count die Anzahl der von Splitzurückgegebenen Zeichen folgen beeinflusst.The following example demonstrates how count affects the number of strings returned by Split.

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

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

// The example displays the following output:
//       The delimiters are - ,.:-
//       count =  1 ..............
//       -one two,three:four.-
//       count =  2 ..............
//       -one-
//       -two,three:four.-
//       count =  3 ..............
//       -one-
//       -two-
//       -three:four.-
//       count =  4 ..............
//       -one-
//       -two-
//       -three-
//       -four.-
//       count =  5 ..............
//       -one-
//       -two-
//       -three-
//       -four-
//       --

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

Hinweise

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

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

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

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

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

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

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

Zeichen folgen WertString value	TrennzeichenSeparator	AnzahlCount	Zurück gegebenes ArrayReturned array
"42, 12, 19""42, 12, 19"	New Char [] {', ', ' '} (C#)new Char[] {',', ' '} (C#) Char () = {"," c "," c} (Visual Basic)Char() = {","c, " "c} (Visual Basic)	22	{"42", " 12, 19"}{"42", " 12, 19"}
"42..12..19""42..12..19"	new Char[] {'.'}new Char[] {'.'} (C#)(C#) Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)	44	{"42", "", "12", ".19"}{"42", "", "12", ".19"}
Bananen"Banana"	new Char[] {'.'}new Char[] {'.'} (C#)(C#) Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)	22	{"Banana"}{"Banana"}
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#) "Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)	New Char [] {} (C#)new Char[] {} (C#) Char () = {} (Visual Basic)Char() = {} (Visual Basic)	11	{"Darb\nsmarba"} (C#){"Darb\nSmarba"} (C#) "Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#) "Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)	New Char [] NULL (C#)new Char[] null (C#) Char () = NothingChar() = Nothing	22	{"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#) "Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)	New Char [] NULL (C#)new Char[] null (C#) Char () = NothingChar() = Nothing	100100	{"Darb", "Smarba"}{"Darb", "Smarba"}

Überlegungen zur LeistungPerformance Considerations

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

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

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

Hinweise für Aufrufer

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

Siehe auch

• Char
• Array
• Int32
• Concat(Object)
• Insert(Int32, String)
• Join(String, String[])
• Remove(Int32, Int32)
• Replace(Char, Char)
• Substring(Int32)
• Trim(Char[])

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

public string[] Split (char separator, StringSplitOptions options = System.StringSplitOptions.None);

member this.Split : char * StringSplitOptions -> string[]

Public Function Split (separator As Char, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parameter

Gibt zurück

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

public string[] Split (string separator, StringSplitOptions options = System.StringSplitOptions.None);

member this.Split : string * StringSplitOptions -> string[]

Public Function Split (separator As String, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parameter

Gibt zurück

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

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

public string[] Split (params char[] separator);

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

Public Function Split (ParamArray separator As Char()) As String()

Parameter

Gibt zurück

Beispiele

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

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

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

foreach (string s in split) 
{

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

// The example displays the following output to the console:
//       This
//       is
//       a
//       list
//       of
//       words
//       with
//       a
//       bit
//       of
//       punctuation
//       and
//       a
//       tab
//       character

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

Hinweise

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

Rückgabewert DetailsReturn value details

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

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

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

Zeichen folgen WertString value	TrennzeichenSeparator	Zurück gegebenes ArrayReturned array
"42, 12, 19""42, 12, 19"	New Char [] {', ', ' '} (C#)new Char[] {',', ' '} (C#) Char () = {"," c "," c} "(Visual Basic)Char() = {","c, " "c}) (Visual Basic)	{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
"42..12..19""42..12..19"	new Char[] {'.'}new Char[] {'.'} (C#)(C#) Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)	{"42", "", "12", "", "19"}{"42", "", "12", "", "19"}
Bananen"Banana"	new Char[] {'.'}new Char[] {'.'} (C#)(C#) Char () = {"." c} (Visual Basic)Char() = {"."c} (Visual Basic)	{"Banana"}{"Banana"}
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#) "Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)	New Char [] {} (C#)new Char[] {} (C#) Char () = {} (Visual Basic)Char() = {} (Visual Basic)	{"Darb", "Smarba"}{"Darb", "Smarba"}
"Darb\nsmarba" (C#)"Darb\nSmarba" (C#) "Darb" & vbLf & "Smarba" (Visual Basic)"Darb" & vbLf & "Smarba" (Visual Basic)	null (C#)null (C#) Nothing (Visual Basic)Nothing (Visual Basic)	{"Darb", "Smarba"}{"Darb", "Smarba"}

Das Trennzeichen ArrayThe separator array

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

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

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

String value = "This is a short string.";
Char delimiter = 's';
String[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
   Console.WriteLine(substring);
// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.

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

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

Vergleichs DetailsComparison details

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

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

Überlegungen zur LeistungPerformance Considerations

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

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

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

Hinweise für Aufrufer

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

Siehe auch

• Char
• Concat(Object)
• Insert(Int32, String)
• Join(String, String[])
• Remove(Int32, Int32)
• Replace(Char, Char)
• Substring(Int32)
• Trim(Char[])