Regex.Split Methode

Definition

Unterteilt eine Eingabezeichenfolge in eine Abfolge von Teilzeichenfolgen, und zwar an den Positionen, die vom Übereinstimmungsmuster für reguläre Ausdrücke festgelegt wurden.Splits an input string into an array of substrings at the positions defined by a regular expression match.

Überlädt

Split(String, String, RegexOptions, TimeSpan)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Split(String, String, RegexOptions)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

Split(String, Int32, Int32)

Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. Die Suche nach dem Muster des regulären Ausdrucks beginnt bei einer angegebenen Zeichenposition in der Eingabezeichenfolge.The search for the regular expression pattern starts at a specified character position in the input string.

Split(String, Int32)

Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

Split(String)

Teilt die angegebene Eingabezeichenfolge an den Positionen in ein Array von Teilzeichenfolgen auf, die durch ein im Regex-Konstruktor angegebenes Muster für einen regulären Ausdruck definiert werden.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

Split(String, String)

Teilt eine Eingabezeichenfolge an den durch ein reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions, TimeSpan)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As String()

Parameter

input
String

Die zu teilende Zeichenfolge.The string to split.

pattern
String

Das Muster des regulären Ausdrucks, mit dem eine Übereinstimmung vorliegen soll.The regular expression pattern to match.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Gibt zurück

String[]

Ein Zeichenfolgenarray.A string array.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input oder pattern ist null, sondern auf ein Paket verweist.input or pattern is null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.options is not a valid bitwise combination of RegexOptions values.

Oder-or- matchTimeout ist negativ, null oder größer als ca. 24 Tage.matchTimeout is negative, zero, or greater than approximately 24 days.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Hinweise

Die Regex.Split-Methoden ähneln der String.Split(Char[])-Methode, mit dem Unterschied, dass Regex.Split die Zeichenfolge bei einem Trennzeichen unterteilt, das durch einen regulären Ausdruck bestimmt wird, anstelle eines Zeichensatzes.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Die Zeichenfolge wird so oft wie möglich aufgeteilt.The string is split as many times as possible. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche input Zeichenfolge ist.If no delimiter is found, the return value contains one element whose value is the original input string.

Der pattern-Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Wichtig

Kompilierte reguläre Ausdrücke, die in Aufrufen von statischen Split Methoden verwendet werden, werden automatisch zwischengespeichert.Compiled regular expressions used in calls to static Split methods are automatically cached. Wenn Sie die Lebensdauer kompilierter regulärer Ausdrücke selbst verwalten möchten, verwenden Sie die Instanz Split Methoden.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Wenn mehrere Übereinstimmungen nebeneinander nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt.If multiple matches are adjacent to one another, an empty string is inserted into the array. Beispielsweise bewirkt das Aufteilen einer Zeichenfolge in einem einzelnen Bindestrich, dass das zurückgegebene Array an der Position, an der zwei angrenzende Bindestriche gefunden werden, eine leere Zeichenfolge enthält.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found.

Wenn eine Entsprechung am Anfang oder am Ende der Eingabe Zeichenfolge gefunden wird, wird am Anfang oder Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingefügt.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. Im folgenden Beispiel wird das Muster für reguläre Ausdrücke [a-z]+ verwendet, um eine Eingabe Zeichenfolge in Großbuchstaben oder in Kleinbuchstaben aufzuteilen.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Da die Zeichenfolge mit übereinstimmenden alphabetischen Zeichen beginnt und endet, wird der Wert des ersten und des letzten Elements des zurückgegebenen Arrays String.Empty.Because the string begins and ends with matching alphabetic characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase,
                                    TimeSpan.FromMilliseconds(500));
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase,
                                           TimeSpan.FromMilliseconds(500))
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Wenn das Erfassen von Klammern in einem Regex.Split Ausdruck verwendet wird, wird der erfasste Text in das resultierende Zeichen folgen Array eingeschlossen.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Wenn Sie z. b. die Zeichenfolge "Plum-Birnen" auf einen Bindestrich aufteilen, der in den Erfassungs Klammern platziert ist, enthält das zurückgegebene Array ein Zeichen folgen Element, das den Bindestrich enthält.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungs Klammern enthält, hängt das Verhalten dieser Methode von der Version der .NET Framework ab.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Wenn in den .NET Framework 1,0 und 1,1 eine Entsprechung nicht innerhalb des ersten Satzes von Erfassungs Klammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungs Klammern nicht im zurückgegebenen Array enthalten.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. Beginnend mit dem .NET Framework 2,0 wird der gesamte erfasste Text dem zurückgegebenen Array ebenfalls hinzugefügt.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Im folgenden Code werden z. b. zwei Sätze von Erfassungs Klammern verwendet, um die Elemente eines Datums, einschließlich der Datums Trennzeichen, aus einer Datums Zeichenfolge zu extrahieren.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. Der erste Satz von Erfassungs Klammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1,0 oder 1,1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn Sie kompiliert und unter dem .NET Framework 2,0 oder höheren Versionen ausgeführt wird, enthält Sie Sie.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Wenn der reguläre Ausdruck mit der leeren Zeichenfolge abgeglichen werden kann, teilt Split die Zeichenfolge in ein Array von Zeichen folgen mit nur einem Zeichen auf, da sich das leere Zeichen folgen Trennzeichen an jedem Speicherort befindet.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location.

Der matchTimeout-Parameter gibt an, wie lange eine Muster Vergleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor ein Timeout auftritt. Das Festlegen eines Timeout Intervalls verhindert, dass reguläre Ausdrücke, die auf einer übermäßigen Rückverfolgung basieren, nicht mehr reagieren, wenn Sie Eingaben verarbeiten, die Near-Übereinstimmungen enthalten.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Weitere Informationen finden Sie unter bewährte Methoden für reguläre Ausdrücke und Rückverfolgung.For more information, see Best Practices for Regular Expressions and Backtracking. Wenn in diesem Zeitintervall keine Entsprechung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout überschreibt jeden Standard Timeout Wert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout-Parameter auf einen geeigneten Wert, z. b. zwei Sekunden, festzulegen.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Wenn Sie Timeouts durch Angeben von InfiniteMatchTimeoutdeaktivieren, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Timeouts sollten jedoch nur unter den folgenden Bedingungen deaktiviert werden:However, you should disable time-outs only under the following conditions: : Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet ist oder aus statischem Text besteht.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.This excludes text that has been dynamically input by users.

: Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, nicht-Übereinstimmungen und NEAR-Übereinstimmungen effizient behandelt.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen eine übermäßige Rückverfolgung verursachen, wenn eine nahe Übereinstimmung verarbeitet wird.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Siehe auch

Split(String, String, RegexOptions)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions) As String()

Parameter

input
String

Die zu teilende Zeichenfolge.The string to split.

pattern
String

Das Muster des regulären Ausdrucks, mit dem eine Übereinstimmung vorliegen soll.The regular expression pattern to match.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.A bitwise combination of the enumeration values that provide options for matching.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.An array of strings.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input oder pattern ist null, sondern auf ein Paket verweist.input or pattern is null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.options is not a valid bitwise combination of RegexOptions values.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Hinweise

Die Regex.Split-Methoden ähneln der String.Split(Char[])-Methode, mit dem Unterschied, dass Regex.Split die Zeichenfolge bei einem Trennzeichen unterteilt, das durch einen regulären Ausdruck bestimmt wird, anstelle eines Zeichensatzes.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Die Zeichenfolge wird so oft wie möglich aufgeteilt.The string is split as many times as possible. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche input Zeichenfolge ist.If no delimiter is found, the return value contains one element whose value is the original input string.

Der pattern-Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Wichtig

Kompilierte reguläre Ausdrücke, die in Aufrufen von statischen Split Methoden verwendet werden, werden automatisch zwischengespeichert.Compiled regular expressions used in calls to static Split methods are automatically cached. Wenn Sie die Lebensdauer kompilierter regulärer Ausdrücke selbst verwalten möchten, verwenden Sie die Instanz Split Methoden.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Wenn mehrere Übereinstimmungen nebeneinander nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt.If multiple matches are adjacent to one another, an empty string is inserted into the array. Beispielsweise bewirkt das Aufteilen einer Zeichenfolge in einem einzelnen Bindestrich, dass das zurückgegebene Array an der Position, an der zwei angrenzende Bindestriche gefunden werden, eine leere Zeichenfolge enthält.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found.

Wenn eine Entsprechung am Anfang oder am Ende der Eingabe Zeichenfolge gefunden wird, wird am Anfang oder Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingefügt.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. Im folgenden Beispiel wird das Muster für reguläre Ausdrücke [a-z]+ verwendet, um eine Eingabe Zeichenfolge in Großbuchstaben oder in Kleinbuchstaben aufzuteilen.The following example uses the regular expression pattern [a-z]+ to split an input string on any uppercase or lowercase alphabetic character. Da die Zeichenfolge mit übereinstimmenden alphabetischen Zeichen beginnt und endet, wird der Wert des ersten und des letzten Elements des zurückgegebenen Arrays String.Empty.Because the string begins and ends with matching alphabetic characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Wenn das Erfassen von Klammern in einem Regex.Split Ausdruck verwendet wird, wird der erfasste Text in das resultierende Zeichen folgen Array eingeschlossen.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Wenn Sie z. b. die Zeichenfolge "Plum-Birnen" auf einen Bindestrich aufteilen, der in den Erfassungs Klammern platziert ist, enthält das zurückgegebene Array ein Zeichen folgen Element, das den Bindestrich enthält.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungs Klammern enthält, hängt das Verhalten dieser Methode von der Version der .NET Framework ab.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Wenn in den .NET Framework 1,0 und 1,1 eine Entsprechung nicht innerhalb des ersten Satzes von Erfassungs Klammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungs Klammern nicht im zurückgegebenen Array enthalten.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. Beginnend mit dem .NET Framework 2,0 wird der gesamte erfasste Text dem zurückgegebenen Array ebenfalls hinzugefügt.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Im folgenden Code werden z. b. zwei Sätze von Erfassungs Klammern verwendet, um die Elemente eines Datums, einschließlich der Datums Trennzeichen, aus einer Datums Zeichenfolge zu extrahieren.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. Der erste Satz von Erfassungs Klammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1,0 oder 1,1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn Sie kompiliert und unter dem .NET Framework 2,0 oder höheren Versionen ausgeführt wird, enthält Sie Sie.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Wenn der reguläre Ausdruck mit der leeren Zeichenfolge abgeglichen werden kann, teilt Split die Zeichenfolge in ein Array von Zeichen folgen mit nur einem Zeichen auf, da sich das leere Zeichen folgen Trennzeichen an jedem Speicherort befindet.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Split-Vorgangs das Timeout Intervall überschreitet, das für die Anwendungsdomäne festgelegt wurde, in der die-Methode aufgerufen wird.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified for the application domain in which the method is called. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Hinweise für Aufrufer

Bei dieser Methode kommt es nach einem Intervall zu einem Timeout, das gleich dem Standard Timeout Wert der Anwendungsdomäne ist, in der die Methode aufgerufen wird.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Wenn für die Anwendungsdomäne kein Timeout Wert definiert wurde, wird der Wert InfiniteMatchTimeout, der verhindert, dass die Methode ein Timeout verursacht, verwendet wird.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Die empfohlene statische Methode zum Aufteilen von Text in einer Muster Übereinstimmung ist Split(String, String, RegexOptions, TimeSpan), mit der Sie das Timeout Intervall festlegen können.The recommended static method for splitting text on a pattern match is Split(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Siehe auch

Split(String, Int32, Int32)

Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. Die Suche nach dem Muster des regulären Ausdrucks beginnt bei einer angegebenen Zeichenposition in der Eingabezeichenfolge.The search for the regular expression pattern starts at a specified character position in the input string.

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

Parameter

input
String

Die aufzuteilende Zeichenfolge.The string to be split.

count
Int32

Die maximale Anzahl der Teilungen.The maximum number of times the split can occur.

startat
Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.The character position in the input string where the search will begin.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.An array of strings.

Ausnahmen

input ist nullinput is null.

startat ist kleiner als 0 (null) oder größer als die Länge von input.startat is less than zero or greater than the length of input.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Hinweise

Die Regex.Split-Methoden ähneln der String.Split-Methode, mit dem Unterschied, dass Regex.Split die Zeichenfolge bei einem Trennzeichen unterteilt, das durch einen regulären Ausdruck bestimmt wird, anstelle eines Zeichensatzes.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Der count-Parameter gibt die maximale Anzahl von Teil Zeichenfolgen an, in die die input Zeichenfolge aufgeteilt ist. die letzte Zeichenfolge enthält den ungeteilten Rest der Zeichenfolge.The count parameter specifies the maximum number of substrings into which the input string is split; the last string contains the unsplit remainder of the string. Ein count Wert von 0 (null) stellt das Standardverhalten der Aufteilung so oft wie möglich dar.A count value of zero provides the default behavior of splitting as many times as possible. Der startat-Parameter definiert den Punkt, an dem die Suche nach dem ersten Trennzeichen beginnt (Dies kann zum Überspringen von führenden Leerzeichen verwendet werden).The startat parameter defines the point at which the search for the first delimiter begins (this can be used for skipping leading white space).

Wenn aus der count+ 1-Position in der Zeichenfolge keine Übereinstimmungen gefunden werden, gibt die-Methode ein Array mit einem Element zurück, das die input Zeichenfolge enthält.If no matches are found from the count+1 position in the string, the method returns a one-element array that contains the input string. Wenn eine oder mehrere Übereinstimmungen gefunden werden, enthält das erste Element des zurückgegebenen Arrays den ersten Teil der Zeichenfolge vom ersten Zeichen bis zu einem Zeichen vor der Übereinstimmung.If one or more matches are found, the first element of the returned array contains the first portion of the string from the first character up to one character before the match.

Wenn mehrere Übereinstimmungen nebeneinander liegen und die Anzahl der gefundenen Übereinstimmungen mindestens zwei kleiner als countist, wird eine leere Zeichenfolge in das Array eingefügt.If multiple matches are adjacent to one another and the number of matches found is at least two less than count, an empty string is inserted into the array. Wenn eine Entsprechung bei startatgefunden wird, bei der es sich um das erste Zeichen in der Zeichenfolge handelt, ist das erste Element des zurückgegebenen Arrays eine leere Zeichenfolge.Similarly, if a match is found at startat, which is the first character in the string, the first element of the returned array is an empty string. Das heißt, leere Zeichen folgen, die sich aus benachbarten Übereinstimmungen ergeben, werden gezählt, um zu bestimmen, ob die Anzahl übereinstimmender Teil Zeichenfolgen countThat is, empty strings that result from adjacent matches are counted in determining whether the number of matched substrings equals count. Im folgenden Beispiel wird der \d+ für reguläre Ausdrücke verwendet, um die Anfangsposition der ersten Teil Zeichenfolge von numerischen Zeichen in einer Zeichenfolge zu finden, und dann die Zeichenfolge maximal dreimal an dieser Position zu teilen.In the following example, the regular expression \d+ is used to find the starting position of the first substring of numeric characters in a string, and then to split the string a maximum of three times starting at that position. Da das Muster für reguläre Ausdrücke mit dem Anfang der Eingabe Zeichenfolge übereinstimmt, besteht das zurückgegebene Zeichen folgen Array aus einer leeren Zeichenfolge, einer Zeichenfolge mit fünf Zeichen und dem Rest der Zeichenfolge.Because the regular expression pattern matches the beginning of the input string, the returned string array consists of an empty string, a five-character alphabetic string, and the remainder of the string,

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJ789KLMNO012PQRST";
      Match m = rgx.Match(input);
      if (m.Success) { 
         int startAt = m.Index;
         string[] result = rgx.Split(input, 3, startAt);
         for (int ctr = 0; ctr < result.Length; ctr++) {
            Console.Write("'{0}'", result[ctr]);
            if (ctr < result.Length - 1)
               Console.Write(", ");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJ789KLMNO012PQRST"
      Dim m As Match = rgx.Match(input)
      If m.Success Then 
         Dim startAt As Integer = m.Index
         Dim result() As String = rgx.Split(input, 3, startAt)
         For ctr As Integer = 0 To result.Length - 1
            Console.Write("'{0}'", result(ctr))
            If ctr < result.Length - 1 Then Console.Write(", ")
         Next
         Console.WriteLine()
      End If
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Wenn die Erfassung von Klammern in einem regulären Ausdruck verwendet wird, werden alle aufgezeichneten Text in das Array von geteilten Zeichen folgen eingefügt.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. Alle Array Elemente, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der Übereinstimmungen counterreicht wurde.However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Wenn Sie z. b. die Zeichenfolge "Apple-Apricot-Plum-Birnen-pomegranat-Ananas-Peach" in maximal vier Teil Zeichenfolgen beginnend mit dem Zeichen 15 in der Zeichenfolge aufteilen, ergibt sich ein Array mit sieben Elementen, wie im folgenden Code gezeigt.For example, splitting the string '"apple-apricot-plum-pear-pomegranate-pineapple-peach" into a maximum of four substrings beginning at character 15 in the string results in a seven-element array, as the following code shows.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-pomegranate-pineapple-peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on hyphens from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'apple-apricot-plum'
'    '-'
'    'pear'
'    '-'
'    'pomegranate'
'    '-'
'    'pineapple-peach'      

Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungs Klammern enthält, hängt das Verhalten dieser Methode von der Version der .NET Framework ab.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Wenn in .NET Framework 1,0 und 1,1 innerhalb des ersten Satzes der Erfassungs Klammern keine Entsprechung gefunden wird, ist erfasster Text aus zusätzlichen Erfassungs Klammern nicht im zurückgegebenen Array enthalten.In .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. Beginnend mit dem .NET Framework 2,0 wird der gesamte erfasste Text dem zurückgegebenen Array ebenfalls hinzugefügt.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Im folgenden Code werden z. b. zwei Sätze von Erfassungs Klammern verwendet, um die einzelnen Wörter in einer Zeichenfolge zu extrahieren.For example, the following code uses two sets of capturing parentheses to extract the individual words in a string. Der erste Satz von Erfassungs Klammern erfasst den Bindestrich, und der zweite Satz erfasst den vertikalen Balken.The first set of capturing parentheses captures the hyphen, and the second set captures the vertical bar. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1,0 oder 1,1 ausgeführt wird, schließt er die senkrechten Strich Zeichen aus. Wenn Sie kompiliert und unter dem .NET Framework 2,0 oder höheren Versionen ausgeführt wird, enthält Sie Sie.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the vertical bar characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)|([|])";     // possible delimiters found in string
      string input = "apple|apricot|plum|pear|pomegranate|pineapple|peach";

      Regex regex = new Regex(pattern);    
      // Split on delimiters from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// In .NET 2.0 and later, the method returns an array of
// 7 elements, as follows:
//    apple|apricot|plum'
//    '|'
//    'pear'
//    '|'
//    'pomegranate'
//    '|'
//    'pineapple|peach'
// In .NET 1.0 and 1.1, the method returns an array of
// 4 elements, as follows:
//    'apple|apricot|plum'
//    'pear'
//    'pomegranate'
//    'pineapple|peach'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)|([|])"   ' possible delimiters found in string
      Dim input As String = "apple|apricot|plum|pear|pomegranate|pineapple|peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on delimiters from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' In .NET 2.0, the method returns an array of
' 7 elements, as follows:
'    apple|apricot|plum'
'    '|'
'    'pear'
'    '|'
'    'pomegranate'
'    '|'
'    'pineapple|peach'
' In .NET 1.0 and 1.1, the method returns an array of
' 4 elements, as follows:
'    'apple|apricot|plum'
'    'pear'
'    'pomegranate'
'    'pineapple|peach'

Wenn der reguläre Ausdruck mit der leeren Zeichenfolge abgeglichen werden kann, teilt Split die Zeichenfolge in ein Array von Zeichen folgen mit nur einem Zeichen auf, da sich das leere Zeichen folgen Trennzeichen an jedem Speicherort befindet.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Im folgenden Beispiel wird die Zeichenfolge "characters" in so viele Elemente wie die Eingabe Zeichenfolge aufgeteilt, beginnend mit dem Zeichen "a".The following example splits the string "characters" into as many elements as the input string contains, starting with the character "a". Da die NULL-Zeichenfolge mit dem Ende der Eingabe Zeichenfolge übereinstimmt, wird am Ende des zurückgegebenen Arrays eine NULL-Zeichenfolge eingefügt.Because the null string matches the end of the input string, a null string is inserted at the end of the returned array.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input, input.Length, input.IndexOf("a"));
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, rs}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length, _
                                               input.IndexOf("a"))
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Split-Vorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan)-Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne kein Timeout definiert ist, oder wenn der Timeout Wert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Siehe auch

Split(String, Int32)

Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

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

Parameter

input
String

Die aufzuteilende Zeichenfolge.The string to be split.

count
Int32

Die maximale Anzahl der Teilungen.The maximum number of times the split can occur.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.An array of strings.

Ausnahmen

input ist nullinput is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Hinweise

Die Regex.Split-Methoden ähneln der String.Split-Methode, mit dem Unterschied, dass Regex.Split die Zeichenfolge bei einem Trennzeichen unterteilt, das durch einen regulären Ausdruck bestimmt wird, anstelle eines Zeichensatzes.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Der count-Parameter gibt die maximale Anzahl von Teil Zeichenfolgen an, in die die input Zeichenfolge aufgeteilt werden kann. die letzte Zeichenfolge enthält den ungeteilten Rest der Zeichenfolge.The count parameter specifies the maximum number of substrings into which the input string can be split; the last string contains the unsplit remainder of the string. Ein count Wert von 0 (null) stellt das Standardverhalten der Aufteilung so oft wie möglich dar.A count value of zero provides the default behavior of splitting as many times as possible.

Wenn mehrere Übereinstimmungen nebeneinander liegen oder wenn am Anfang oder Ende inputeine Übereinstimmung gefunden wird und die Anzahl der gefundenen Übereinstimmungen mindestens zwei kleiner als countist, wird eine leere Zeichenfolge in das Array eingefügt.If multiple matches are adjacent to one another or if a match is found at the beginning or end of input, and the number of matches found is at least two less than count, an empty string is inserted into the array. Das heißt, dass leere Zeichen folgen, die sich aus benachbarten Übereinstimmungen oder Übereinstimmungen am Anfang oder Ende der Eingabe Zeichenfolge ergeben, bei der Bestimmung gezählt werden, ob die Anzahl der übereinstimmenden Teil Zeichenfolgen countentsprichtThat is, empty strings that result from adjacent matches or from matches at the beginning or end of the input string are counted in determining whether the number of matched substrings equals count. Im folgenden Beispiel wird der /d+ für reguläre Ausdrücke verwendet, um eine Eingabe Zeichenfolge mit einer oder mehreren Dezimalziffern in maximal drei Teil Zeichenfolgen aufzuteilen.In the following example, the regular expression /d+ is used to split an input string that includes one or more decimal digits into a maximum of three substrings. Da der Anfang der Eingabe Zeichenfolge mit dem Muster des regulären Ausdrucks übereinstimmt, enthält das erste Array Element String.Empty, das zweite Element den ersten Satz von alphabetischen Zeichen in der Eingabe Zeichenfolge, und das dritte enthält den Rest der Zeichenfolge, die auf die dritte Übereinstimmung folgt.Because the beginning of the input string matches the regular expression pattern, the first array element contains String.Empty, the second contains the first set of alphabetic characters in the input string, and the third contains the remainder of the string that follows the third match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input, 3);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input, 3)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Wenn die Erfassung von Klammern in einem regulären Ausdruck verwendet wird, werden alle aufgezeichneten Text in das Array von geteilten Zeichen folgen eingefügt.If capturing parentheses are used in a regular expression, any captured text is included in the array of split strings. Alle Array Elemente, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der Übereinstimmungen counterreicht wurde.However, any array elements that contain captured text are not counted in determining whether the number of matches has reached count. Wenn Sie z. b. die Zeichenfolge "Apple-Apricot-Plum-Birnen-Banane" in maximal vier Teil Zeichenfolgen aufteilen, ergibt sich ein Array mit sieben Elementen, wie im folgenden Code gezeigt.For example, splitting the string "apple-apricot-plum-pear-banana" into a maximum of four substrings results in a seven-element array, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-banana";
      Regex regex = new Regex(pattern);         // Split on hyphens.
      string[] substrings = regex.Split(input, 4);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//       'apple'
//       '-'
//       'apricot'
//       '-'
//       'plum'
//       '-'
//       'pear-banana'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-banana"
      Dim regex As Regex = New Regex(pattern)         ' Split on hyphens.
      Dim substrings() As String = regex.Split(input, 4)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'apple'
'    '-'
'    'apricot'
'    '-'
'    'plum'
'    '-'
'    'pear-banana'      

Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungs Klammern enthält, hängt das Verhalten dieser Methode von der Version der .NET Framework ab.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. In den .NET Framework 1,0 und 1,1 ist nur erfasster Text aus dem ersten Satz von Erfassungs Klammern im zurückgegebenen Array enthalten.In the .NET Framework 1.0 and 1.1, only captured text from the first set of capturing parentheses is included in the returned array. Beginnend mit dem .NET Framework 2,0 wird der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt.Starting with the .NET Framework 2.0, all captured text is added to the returned array. Elemente im zurückgegebenen Array, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der übereinstimmenden Teil Zeichenfolgen countentspricht.However, elements in the returned array that contain captured text are not counted in determining whether the number of matched substrings equals count. Im folgenden Code werden z. b. in einem regulären Ausdruck zwei Sätze von Erfassungs Klammern verwendet, um die Elemente eines Datums aus einer Datums Zeichenfolge zu extrahieren.For example, in the following code, a regular expression uses two sets of capturing parentheses to extract the elements of a date from a date string. Der erste Satz von Erfassungs Klammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Der-Befehl für die Split(String, Int32)-Methode gibt dann maximal zwei Elemente im zurückgegebenen Array an.The call to the Split(String, Int32) method then specifies a maximum of two elements in the returned array. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1,0 oder 1,1 ausgeführt wird, gibt die Methode ein Zeichen folgen Array mit zwei Elementen zurück.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, the method returns a two-element string array. Wenn Sie kompiliert und unter dem .NET Framework 2,0 oder höheren Versionen ausgeführt wird, gibt die Methode ein Zeichen folgen Array mit drei Elementen zurück.If it is compiled and run under the .NET Framework 2.0 or later versions, the method returns a three-element string array.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input, 2)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 2 elements, as follows:
//    '07'
//    '14/2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '/'
//    '14/2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input, 2) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 2 elements, as follows:
'    '07'
'    '14/2007'
'
' In .NET 2.0 and later, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '/'
'    '14/2007' 

Wenn der reguläre Ausdruck mit der leeren Zeichenfolge abgeglichen werden kann, teilt Split(String, Int32) die Zeichenfolge in ein Array von Zeichen folgen mit nur einem Zeichen auf, da sich das leere Zeichen folgen Trennzeichen an jedem Speicherort befindet.If the regular expression can match the empty string, Split(String, Int32) will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Im folgenden Beispiel wird die Zeichenfolge "characters" in so viele Elemente aufgeteilt, wie Sie in der Eingabe Zeichenfolge enthalten sind.The following example splits the string "characters" into as many elements as there are in the input string. Da die NULL-Zeichenfolge mit dem Anfang der Eingabe Zeichenfolge übereinstimmt, wird am Anfang des zurückgegebenen Arrays eine NULL-Zeichenfolge eingefügt.Because the null string matches the beginning of the input string, a null string is inserted at the beginning of the returned array. Dies bewirkt, dass das zehnte Element aus den beiden Zeichen am Ende der Eingabe Zeichenfolge besteht.This causes the tenth element to consist of the two characters at the end of the input string.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         if ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example displays the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Split-Vorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan)-Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne kein Timeout definiert ist, oder wenn der Timeout Wert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Siehe auch

Split(String)

Teilt die angegebene Eingabezeichenfolge an den Positionen in ein Array von Teilzeichenfolgen auf, die durch ein im Regex-Konstruktor angegebenes Muster für einen regulären Ausdruck definiert werden.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input);
public string[] Split (string input);
member this.Split : string -> string[]
Public Function Split (input As String) As String()

Parameter

input
String

Die zu teilende Zeichenfolge.The string to split.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.An array of strings.

Ausnahmen

input ist nullinput is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Hinweise

Die Regex.Split-Methoden ähneln der String.Split(Char[])-Methode, mit dem Unterschied, dass Regex.Split die Zeichenfolge bei einem Trennzeichen unterteilt, das durch einen regulären Ausdruck bestimmt wird, anstelle eines Zeichensatzes.The Regex.Split methods are similar to the String.Split(Char[]) method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Die Zeichenfolge wird so oft wie möglich aufgeteilt.The string is split as many times as possible. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert der ursprünglichen Eingabe Zeichenfolge entspricht.If no delimiter is found, the return value contains one element whose value is the original input string.

Wenn mehrere Übereinstimmungen nebeneinander nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt.If multiple matches are adjacent to one another, an empty string is inserted into the array. Beispielsweise bewirkt das Aufteilen einer Zeichenfolge in einem einzelnen Bindestrich, dass das zurückgegebene Array eine leere Zeichenfolge an der Position enthält, an der zwei angrenzende Bindestriche gefunden werden, wie der folgende Code zeigt.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("-");         // Split on hyphens.
      string[] substrings = regex.Split("plum--pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    ''
//    'pear'      
Imports System.Text.RegularExpressions

Module RegexSplit
   Public Sub Main()
      Dim regex As Regex = New Regex("-")         ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum--pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'      

Wenn eine Entsprechung am Anfang oder am Ende der Eingabe Zeichenfolge gefunden wird, wird am Anfang oder Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingefügt.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. Im folgenden Beispiel wird das Muster für reguläre Ausdrücke \d+ verwendet, um eine Eingabe Zeichenfolge auf numerische Zeichen aufzuteilen.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. Da die Zeichenfolge mit übereinstimmenden numerischen Zeichen beginnt und endet, wird der Wert des ersten und des letzten Elements des zurückgegebenen Arrays String.Empty.Because the string begins and ends with matching numeric characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Wenn das Erfassen von Klammern in einem Regex.Split Ausdruck verwendet wird, wird der erfasste Text in das resultierende Zeichen folgen Array eingeschlossen.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Wenn Sie z. b. die Zeichenfolge "Plum-Birnen" auf einen Bindestrich aufteilen, der in den Erfassungs Klammern platziert ist, enthält das zurückgegebene Array ein Zeichen folgen Element, das den Bindestrich enthält.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("(-)");         // Split on hyphens.
      string[] substrings = regex.Split("plum-pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim regex As Regex = New Regex("(-)")          ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum-pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    '-'
'    'pear'      

Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungs Klammern enthält, hängt das Verhalten dieser Methode von der Version der .NET Framework ab.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Wenn in den .NET Framework 1,0 und 1,1 eine Entsprechung nicht innerhalb des ersten Satzes von Erfassungs Klammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungs Klammern nicht im zurückgegebenen Array enthalten.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. Beginnend mit dem .NET Framework 2,0 wird der gesamte erfasste Text dem zurückgegebenen Array ebenfalls hinzugefügt.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Im folgenden Code werden z. b. zwei Sätze von Erfassungs Klammern verwendet, um die Elemente eines Datums, einschließlich der Datums Trennzeichen, aus einer Datums Zeichenfolge zu extrahieren.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. Der erste Satz von Erfassungs Klammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1,0 oder 1,1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn Sie kompiliert und unter dem .NET Framework 2,0 oder höheren Versionen ausgeführt wird, enthält Sie Sie.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Wenn der reguläre Ausdruck mit der leeren Zeichenfolge abgeglichen werden kann, teilt Split(String) die Zeichenfolge in ein Array von Zeichen folgen mit nur einem Zeichen auf, da sich das leere Zeichen folgen Trennzeichen an jedem Speicherort befindet.If the regular expression can match the empty string, Split(String) will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Beispiel:For example:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input);
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, r, s, }
Imports System.Text.RegularExpressions

Module Main
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, r, s, }

Beachten Sie, dass das zurückgegebene Array auch eine leere Zeichenfolge am Anfang und am Ende des Arrays enthält.Note that the returned array also includes an empty string at the beginning and end of the array.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Split-Vorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan)-Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne kein Timeout definiert ist, oder wenn der Timeout Wert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Siehe auch

Split(String, String)

Teilt eine Eingabezeichenfolge an den durch ein reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern);
public static string[] Split (string input, string pattern);
static member Split : string * string -> string[]
Public Shared Function Split (input As String, pattern As String) As String()

Parameter

input
String

Die zu teilende Zeichenfolge.The string to split.

pattern
String

Das Muster des regulären Ausdrucks, mit dem eine Übereinstimmung vorliegen soll.The regular expression pattern to match.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.An array of strings.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input oder pattern ist null, sondern auf ein Paket verweist.input or pattern is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Hinweise

Die Regex.Split-Methoden ähneln der String.Split-Methode, mit dem Unterschied, dass Regex.Split die Zeichenfolge bei einem Trennzeichen unterteilt, das durch einen regulären Ausdruck bestimmt wird, anstelle eines Zeichensatzes.The Regex.Split methods are similar to the String.Split method, except that Regex.Split splits the string at a delimiter determined by a regular expression instead of a set of characters. Die input Zeichenfolge wird so oft wie möglich aufgeteilt.The input string is split as many times as possible. Wenn pattern nicht in der input Zeichenfolge gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche input Zeichenfolge ist.If pattern is not found in the input string, the return value contains one element whose value is the original input string.

Der pattern-Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Wichtig

Kompilierte reguläre Ausdrücke, die in Aufrufen von statischen Split Methoden verwendet werden, werden automatisch zwischengespeichert.Compiled regular expressions used in calls to static Split methods are automatically cached. Wenn Sie die Lebensdauer kompilierter regulärer Ausdrücke selbst verwalten möchten, verwenden Sie die Instanz Split Methoden.To manage the lifetime of compiled regular expressions yourself, use the instance Split methods.

Wenn mehrere Übereinstimmungen nebeneinander nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt.If multiple matches are adjacent to one another, an empty string is inserted into the array. Beispielsweise bewirkt das Aufteilen einer Zeichenfolge in einem einzelnen Bindestrich, dass das zurückgegebene Array eine leere Zeichenfolge an der Position enthält, an der zwei angrenzende Bindestriche gefunden werden, wie der folgende Code zeigt.For example, splitting a string on a single hyphen causes the returned array to include an empty string in the position where two adjacent hyphens are found, as the following code shows.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum--pear";
      string pattern = "-";            // Split on hyphens
      
      string[] substrings = Regex.Split(input, pattern);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method displays the following output:
//    'plum'
//    ''
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum--pear"
      Dim pattern As String = "-"          ' Split on hyphens
      
      Dim substrings() As String = Regex.Split(input, pattern)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'      

Wenn eine Entsprechung am Anfang oder am Ende der Eingabe Zeichenfolge gefunden wird, wird am Anfang oder Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingefügt.If a match is found at the beginning or the end of the input string, an empty string is included at the beginning or the end of the returned array. Im folgenden Beispiel wird das Muster für reguläre Ausdrücke \d+ verwendet, um eine Eingabe Zeichenfolge auf numerische Zeichen aufzuteilen.The following example uses the regular expression pattern \d+ to split an input string on numeric characters. Da die Zeichenfolge mit übereinstimmenden numerischen Zeichen beginnt und endet, wird der Wert des ersten und des letzten Elements des zurückgegebenen Arrays String.Empty.Because the string begins and ends with matching numeric characters, the value of the first and last element of the returned array is String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      string[] result = Regex.Split(input, pattern);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      Dim result() As String = Regex.Split(input, pattern)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Wenn das Erfassen von Klammern in einem Regex.Split Ausdruck verwendet wird, wird der erfasste Text in das resultierende Zeichen folgen Array eingeschlossen.If capturing parentheses are used in a Regex.Split expression, any captured text is included in the resulting string array. Wenn Sie z. b. die Zeichenfolge "Plum-Birnen" auf einen Bindestrich aufteilen, der in den Erfassungs Klammern platziert ist, enthält das zurückgegebene Array ein Zeichen folgen Element, das den Bindestrich enthält.For example, if you split the string "plum-pear" on a hyphen placed within capturing parentheses, the returned array includes a string element that contains the hyphen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'      
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'      

Wenn das Muster für reguläre Ausdrücke jedoch mehrere Sätze von Erfassungs Klammern enthält, hängt das Verhalten dieser Methode von der Version der .NET Framework ab.However, when the regular expression pattern includes multiple sets of capturing parentheses, the behavior of this method depends on the version of the .NET Framework. Wenn in den .NET Framework 1,0 und 1,1 eine Entsprechung nicht innerhalb des ersten Satzes von Erfassungs Klammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungs Klammern nicht im zurückgegebenen Array enthalten.In the .NET Framework 1.0 and 1.1, if a match is not found within the first set of capturing parentheses, captured text from additional capturing parentheses is not included in the returned array. Beginnend mit dem .NET Framework 2,0 wird der gesamte erfasste Text dem zurückgegebenen Array ebenfalls hinzugefügt.Starting with the .NET Framework 2.0, all captured text is also added to the returned array. Im folgenden Code werden z. b. zwei Sätze von Erfassungs Klammern verwendet, um die Elemente eines Datums, einschließlich der Datums Trennzeichen, aus einer Datums Zeichenfolge zu extrahieren.For example, the following code uses two sets of capturing parentheses to extract the elements of a date, including the date delimiters, from a date string. Der erste Satz von Erfassungs Klammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich.The first set of capturing parentheses captures the hyphen, and the second set captures the forward slash. Wenn der Beispielcode kompiliert und unter dem .NET Framework 1,0 oder 1,1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn Sie kompiliert und unter dem .NET Framework 2,0 oder höheren Versionen ausgeführt wird, enthält Sie Sie.If the example code is compiled and run under the .NET Framework 1.0 or 1.1, it excludes the slash characters; if it is compiled and run under the .NET Framework 2.0 or later versions, it includes them.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007' 
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007' 

Wenn der reguläre Ausdruck mit der leeren Zeichenfolge abgeglichen werden kann, teilt Split die Zeichenfolge in ein Array von Zeichen folgen mit nur einem Zeichen auf, da sich das leere Zeichen folgen Trennzeichen an jedem Speicherort befindet.If the regular expression can match the empty string, Split will split the string into an array of single-character strings because the empty string delimiter can be found at every location. Beispiel:For example:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      string[] substrings = Regex.Split(input, "");
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write("'{0}'", substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example produces the following output:   
//    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim substrings() As String = Regex.Split(input, "")
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write("'{0}'", substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

Beachten Sie, dass das zurückgegebene Array auch eine leere Zeichenfolge am Anfang und am Ende des Arrays enthält.Note that the returned array also includes an empty string at the beginning and end of the array.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Split-Vorgangs das Timeout Intervall überschreitet, das für die Anwendungsdomäne festgelegt wurde, in der die-Methode aufgerufen wird.The RegexMatchTimeoutException exception is thrown if the execution time of the split operation exceeds the time-out interval specified for the application domain in which the method is called. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Hinweise für Aufrufer

Bei dieser Methode kommt es nach einem Intervall zu einem Timeout, das gleich dem Standard Timeout Wert der Anwendungsdomäne ist, in der die Methode aufgerufen wird.This method times out after an interval that is equal to the default time-out value of the application domain in which the method is called. Wenn für die Anwendungsdomäne kein Timeout Wert definiert wurde, wird der Wert InfiniteMatchTimeout, der verhindert, dass die Methode ein Timeout verursacht, verwendet wird.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Die empfohlene statische Methode zum Aufteilen von Text in einer Muster Übereinstimmung ist Split(String, String, RegexOptions, TimeSpan), mit der Sie das Timeout Intervall festlegen können.The recommended static method for splitting text on a pattern match is Split(String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Siehe auch

Gilt für: