Regex.Split Methode

Definition

Teilt eine Eingabezeichenfolge an den Positionen in ein Array von Teilzeichenfolgen auf, die durch eine Übereinstimmung mit einem regulären Ausdruck definiert werden.

Ü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. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.

Split(String, String, RegexOptions)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.

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. Die Suche nach dem Muster des regulären Ausdrucks beginnt bei einer angegebenen Zeichenposition in der Eingabezeichenfolge.

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.

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.

Split(String, String)

Teilt eine Eingabezeichenfolge an den durch ein reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.

Split(String, String, RegexOptions, TimeSpan)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.

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.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

matchTimeout
TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.

Gibt zurück

String[]

Ein Zeichenfolgenarray.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input oder pattern ist null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

- oder - matchTimeout ist negativ, null oder größer als ca. 24 Tage.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

Die Regex.Split Methoden ähneln der String.Split(Char[]) -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufteilt, das durch einen regulären Ausdruck anstelle eines Zeichensatzes bestimmt wird. Die Zeichenfolge wird so oft wie möglich geteilt. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche input Zeichenfolge ist.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die abzugleichende Zeichenfolge symbolisch beschreiben. 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.

Wichtig

Kompilierte reguläre Ausdrücke, die in Aufrufen statischer Methoden verwendet Split werden, werden automatisch zwischengespeichert. Verwenden Sie die Instanzmethoden, um die Lebensdauer kompilierter regulärer Ausdrücke selbst zu Split verwalten.

Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Beispielsweise bewirkt das Teilen 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.

Wenn am Anfang oder Ende der Eingabezeichenfolge eine Übereinstimmung gefunden wird, wird am Anfang oder Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingefügt. Im folgenden Beispiel wird das Muster des regulären Ausdrucks [a-z]+ verwendet, um eine Eingabezeichenfolge in groß- oder kleingeschriebene alphabetische Zeichen aufzuteilen. Da die Zeichenfolge mit übereinstimmenden alphabetischen Zeichen beginnt und endet, ist der Wert des ersten und letzten Elements des zurückgegebenen Arrays 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 erfassungsklammern in einem Ausdruck verwendet Regex.Split werden, wird jeder erfasste Text in das resultierende Zeichenfolgenarray eingefügt. Wenn Sie z. B. die Zeichenfolge "plum-pear" auf einen Bindestrich teilen, der in erfassungsklammern platziert ist, enthält das zurückgegebene Array ein Zeichenfolgenelement, das den Bindestrich enthält.

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 Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Wenn im .NET Framework 1.0 und 1.1 innerhalb des ersten Satzes von Erfassungsklammern keine Übereinstimmung gefunden wird, ist erfasster Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird der gesamte erfasste Text auch dem zurückgegebenen Array hinzugefügt. Im folgenden Code werden beispielsweise zwei Sätze von Erfassungsklammern verwendet, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und die zweite Gruppe erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter der .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn sie kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, enthält sie diese.

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 übereinstimmen kann, teilt die Zeichenfolge in ein Array von Zeichenfolgen mit nur einem Zeichen auf, Split da das leere Zeichenfolgentrennzeichen an jeder Stelle gefunden werden kann.

Der matchTimeout -Parameter gibt an, wie lange eine Musterabgleichsmethode versuchen soll, eine Übereinstimmung zu finden, bevor ein Zeitauslauf erfolgt. Das Festlegen eines Time out-Intervalls verhindert, dass reguläre Ausdrücke, die auf übermäßiger Rückverfolgung basieren, nicht mehr reagieren, wenn sie Eingaben verarbeiten, die nahezu Übereinstimmungen enthalten. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke und Rückverfolgung. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standardtime out-Wert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Time outs deaktivieren, indem Sie InfiniteMatchTimeout angeben, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Time outs sollten jedoch nur unter den folgenden Bedingungen deaktiviert werden: – Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dadurch wird Text ausgeschlossen, der von Benutzern dynamisch eingegeben wurde.

– Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass übereinstimmungen, nicht übereinstimmende und nahezu übereinstimmende Übereinstimmungen effizient verarbeitet werden.

– Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen eine übermäßige Rückverfolgung verursachen, wenn eine Nahezu-Übereinstimmung verarbeitet wird.

Siehe auch

Gilt für

Split(String, String, RegexOptions)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.

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.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input oder pattern ist null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

Die Methoden ähneln der -Methode, mit der Ausnahme, dass die Zeichenfolge an einem Trennzeichen aufteilt, das durch einen regulären Ausdruck anstelle einer Gruppe Regex.Split String.Split(Char[]) von Zeichen bestimmt Regex.Split wird. Die Zeichenfolge wird so oft wie möglich aufgeteilt. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche Zeichenfolge input ist.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzreferenz.

Wichtig

Kompilierte reguläre Ausdrücke, die in Aufrufen statischer Methoden Split verwendet werden, werden automatisch zwischengespeichert. Verwenden Sie die Instanzmethoden, um die Lebensdauer kompilierter regulärer Ausdrücke selbst Split zu verwalten.

Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Wenn Sie beispielsweise eine Zeichenfolge auf einen einzelnen Bindestrich aufteilen, enthält das zurückgegebene Array eine leere Zeichenfolge an der Position, an der zwei angrenzende Bindestriche gefunden werden.

Wenn am Anfang oder Ende der Eingabezeichenfolge eine Übereinstimmung gefunden wird, wird am Anfang oder Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. Im folgenden Beispiel wird das Muster des regulären Ausdrucks [a-z]+ verwendet, um eine Eingabezeichenfolge in groß- oder kleingeschriebene alphabetische Zeichen aufzuteilen. Da die Zeichenfolge mit übereinstimmenden alphabetischen Zeichen beginnt und endet, ist der Wert des ersten und letzten Elements des zurückgegebenen Arrays 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 erfassungsklammern in einem Ausdruck verwendet Regex.Split werden, wird jeder erfasste Text in das resultierende Zeichenfolgenarray eingefügt. Wenn Sie z. B. die Zeichenfolge "plum-pear" auf einen Bindestrich teilen, der in erfassungsklammern platziert ist, enthält das zurückgegebene Array ein Zeichenfolgenelement, das den Bindestrich enthält.

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 Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Wenn im .NET Framework 1.0 und 1.1 innerhalb des ersten Satzes von Erfassungsklammern keine Übereinstimmung gefunden wird, ist erfasster Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird der gesamte erfasste Text auch dem zurückgegebenen Array hinzugefügt. Im folgenden Code werden beispielsweise zwei Sätze von Erfassungsklammern verwendet, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und die zweite Gruppe erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter der .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn sie kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, enthält sie diese.

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 übereinstimmen kann, teilt die Zeichenfolge in ein Array von Zeichenfolgen mit nur einem Zeichen auf, Split da das leere Zeichenfolgentrennzeichen an jeder Stelle gefunden werden kann.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Teilungsvorgangs das für die Anwendungsdomäne, in der die Methode aufgerufen wird, angegebene Time out-Intervall überschreitet. Wenn in den Eigenschaften der Anwendungsdomäne kein Time out definiert ist oder der Time out-Wert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Diese Methode führt nach einem Intervall zu einem Time out, das dem Standardtime out-Wert der Anwendungsdomäne entspricht, in der die Methode aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Timeout aufgetreten ist. Die empfohlene statische Methode zum Teilen von Text für eine Muster übereinstimmung ist Split(String, String, RegexOptions, TimeSpan) , mit der Sie das Time out-Intervall festlegen können.

Siehe auch

Gilt für

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. Die Suche nach dem Muster des regulären Ausdrucks beginnt bei einer angegebenen Zeichenposition in der Eingabezeichenfolge.

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.

count
Int32

Die maximale Anzahl der Teilungen.

startat
Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.

Ausnahmen

input ist null.

startat ist kleiner als 0 (null) oder größer als die Länge von input.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

Die Methoden ähneln der -Methode, mit der Ausnahme, dass die Zeichenfolge an einem Trennzeichen aufteilt, das durch einen regulären Ausdruck anstelle einer Gruppe Regex.Split String.Split von Zeichen bestimmt Regex.Split wird. Der -Parameter gibt die maximale Anzahl von Teilzeichenfolgen an, in die die Zeichenfolge aufgeteilt wird. Die letzte Zeichenfolge enthält den nicht aufgeteilten count input Rest der Zeichenfolge. Der count Wert 0 (null) stellt das Standardverhalten der Teilung so oft wie möglich zurVerfeinern. Der -Parameter definiert den Punkt, an dem die Suche nach dem ersten Trennzeichen beginnt (dies kann verwendet werden, um führende Leerzeichen startat zu überspringen).

Wenn von der Position +1 in der Zeichenfolge keine Übereinstimmungen gefunden werden, gibt die Methode ein count Ein-Element-Array zurück, das die Zeichenfolge input enthält. 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.

Wenn mehrere Übereinstimmungen nebeneinander liegen und die Anzahl gefundener Übereinstimmungen mindestens zwei kleiner als ist, wird eine leere Zeichenfolge count in das Array eingefügt. Wenn bei eine Übereinstimmung gefunden wird, bei der es sich um das erste Zeichen in der Zeichenfolge handelt, ist das erste Element des zurückgegebenen Arrays startat eine leere Zeichenfolge. Das heißt, leere Zeichenfolgen, die sich aus angrenzenden Übereinstimmungen ergeben, werden bei der Bestimmung gezählt, ob die Anzahl der übereinstimmenden Teilzeichenfolgen gleich count ist. Im folgenden Beispiel wird der reguläre Ausdruck verwendet, um die Anfangsposition der ersten Teilzeichenfolge numerischer Zeichen in einer Zeichenfolge zu suchen und die Zeichenfolge dann maximal dreimal zu teilen, beginnend an dieser \d+ Position. Da das Muster für reguläre Ausdrücke dem Anfang der Eingabezeichenfolge entspricht, besteht das zurückgegebene Zeichenfolgenarray aus einer leeren Zeichenfolge, einer alphabetischen Zeichenfolge mit fünf Zeichen und dem Rest der Zeichenfolge.

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 das Erfassen von Klammern in einem regulären Ausdruck verwendet wird, wird jeder erfasste Text in das Array der geteilten Zeichenfolgen aufgenommen. Arrayelemente, die erfassten Text enthalten, werden jedoch nicht bei der Bestimmung gezählt, ob die Anzahl der Übereinstimmungen erreicht count hat. Wenn Sie z. B. die Zeichenfolge ""apple-apricot-plum-pear-pome wie im folgenden Code gezeigt" in maximal vier Teilzeichenfolgen aufteilen, beginnend bei Zeichen 15 in der Zeichenfolge, ergibt sich ein Array mit sieben Elemente.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-pomegranate-pineapple-peach";

      // Split on hyphens from 15th character on
      Regex regex = new Regex(pattern);    
      // Split on hyphens from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method writes the following to the console:
//    'apple-apricot-plum'
//    '-'
//    'pear'
//    '-'
//    'pomegranate'
//    '-'
//    'pineapple-peach'
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 Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version der .NET Framework. Wenn .NET Framework 1.0 und 1.1 in der ersten Gruppe von erfassungsklammern keine Übereinstimmung gefunden wird, ist der erfasste Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab der .NET Framework 2.0 wird auch der erfasste Text dem zurückgegebenen Array hinzugefügt. Der folgende Code verwendet beispielsweise zwei Sätze von Erfassungsklammern, um die einzelnen Wörter in einer Zeichenfolge zu extrahieren. Der erste Satz von erfassungsklammern erfasst den Bindestrich, und der zweite Satz erfasst den vertikalen Strich. Wenn der Beispielcode kompiliert und unter .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die vertikalen Strichzeichen ausgeschlossen. Wenn sie kompiliert und unter der Version .NET Framework 2.0 oder höher ausgeführt wird, enthält sie diese.

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 übereinstimmen kann, teilt die Zeichenfolge in ein Array von Zeichenfolgen mit nur einem Zeichen auf, da das leere Zeichenfolgentrennzeichen an jeder Position Split gefunden werden kann. Im folgenden Beispiel wird die Zeichenfolge "characters" in so viele Elemente aufgeteilt, wie die Eingabezeichenfolge enthält, beginnend mit dem Zeichen "a". Da die NULL-Zeichenfolge dem Ende der Eingabezeichenfolge entspricht, wird am Ende des zurückgegebenen Arrays eine NULL-Zeichenfolge eingefügt.

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 Ausnahme wird ausgelöst, wenn die Ausführungszeit des Teilungsvorgang das vom Konstruktor angegebene Time RegexMatchTimeoutException out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Objekt erstellt Regex wird. Wenn kein Time out im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Time Regex out-Wert ist, wird Regex.InfiniteMatchTimeout keine Ausnahme ausgelöst.

Siehe auch

Gilt für

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.

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.

count
Int32

Die maximale Anzahl der Teilungen.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.

Ausnahmen

input ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

Die Regex.Split Methoden ähneln der String.Split -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufteilt, das durch einen regulären Ausdruck anstelle eines Zeichensatzes bestimmt wird. Der count -Parameter gibt die maximale Anzahl von Teilzeichenfolgen an, in die die input Zeichenfolge aufgeteilt werden kann. Die letzte Zeichenfolge enthält den nicht angewendeten Rest der Zeichenfolge. Der count Wert 0 (null) stellt das Standardverhalten der Teilung so oft wie möglich bereit.

Wenn mehrere Übereinstimmungen nebeneinander liegen oder eine Übereinstimmung am Anfang oder Ende von gefunden wird input und die Anzahl der gefundenen Übereinstimmungen mindestens zwei kleiner als count ist, wird eine leere Zeichenfolge in das Array eingefügt. Das heißt, leere Zeichenfolgen, die sich aus benachbarten Übereinstimmungen oder Übereinstimmungen am Anfang oder Ende der Eingabezeichenfolge ergeben, werden bei der Bestimmung gezählt, ob die Anzahl der übereinstimmenden Teilzeichenfolgen gleich count ist. Im folgenden Beispiel wird der reguläre Ausdruck /d+ verwendet, um eine Eingabezeichenfolge, die eine oder mehrere Dezimalstellen enthält, in maximal drei Teilzeichenfolgen aufzuteilen. Da der Anfang der Eingabezeichenfolge mit dem Muster des regulären Ausdrucks übereinstimmt, enthält das erste Arrayelement String.Empty , das zweite enthält den ersten Satz alphabetischer Zeichen in der Eingabezeichenfolge, und das dritte enthält den Rest der Zeichenfolge, die auf die dritte Übereinstimmung folgt.

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, wird jeder erfasste Text in das Array der geteilten Zeichenfolgen aufgenommen. Arrayelemente, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der Übereinstimmungen erreicht count wurde. Wenn Sie z. B. die Zeichenfolge "apple-apricot-plum-pear-bane" in maximal vier Teilzeichenfolgen aufteilen, ergibt sich ein Array mit sieben Elementen, wie der folgende Code zeigt.

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 Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Im .NET Framework 1.0 und 1.1 ist nur erfasster Text aus dem ersten Satz von Erfassungsklammern im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt. Elemente im zurückgegebenen Array, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der übereinstimmenden Teilzeichenfolgen gleich count ist. Im folgenden Code verwendet ein regulärer Ausdruck beispielsweise zwei Sätze von Erfassungsklammern, um die Elemente eines Datums aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und die zweite Gruppe erfasst den Schrägstrich. Der Aufruf der Split(String, Int32) -Methode gibt dann maximal zwei Elemente im zurückgegebenen Array an. Wenn der Beispielcode kompiliert und unter der .NET Framework 1.0 oder 1.1 ausgeführt wird, gibt die Methode ein Zeichenfolgenarray mit zwei Elementen zurück. Wenn sie kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, gibt die Methode ein Array mit drei Elementen zurück.

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 übereinstimmen kann, teilt die Zeichenfolge in ein Array von Zeichenfolgen mit nur einem Zeichen auf, Split(String, Int32) da das leere Zeichenfolgentrennzeichen an jeder Stelle gefunden werden kann. Im folgenden Beispiel wird die Zeichenfolge "characters" in so viele Elemente aufgeteilt, wie in der Eingabezeichenfolge enthalten sind. Da die NULL-Zeichenfolge dem Anfang der Eingabezeichenfolge entspricht, wird am Anfang des zurückgegebenen Arrays eine NULL-Zeichenfolge eingefügt. Dies bewirkt, dass das zehnte Element aus den beiden Zeichen am Ende der Eingabezeichenfolge besteht.

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 Ausnahme wird ausgelöst, wenn die Ausführungszeit des Teilungsvorgang das vom Konstruktor angegebene Time RegexMatchTimeoutException out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Objekt erstellt Regex wird. Wenn kein Time out im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Time Regex out-Wert ist, wird Regex.InfiniteMatchTimeout keine Ausnahme ausgelöst.

Siehe auch

Gilt für

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.

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.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.

Ausnahmen

input ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

Die Regex.Split Methoden ähneln der String.Split(Char[]) -Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen aufteilt, das durch einen regulären Ausdruck anstelle eines Zeichensatzes bestimmt wird. Die Zeichenfolge wird so oft wie möglich geteilt. Wenn kein Trennzeichen gefunden wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche Eingabezeichenfolge ist.

Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Beispielsweise bewirkt das Teilen 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.

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 am Anfang oder Ende der Eingabezeichenfolge eine Übereinstimmung gefunden wird, wird am Anfang oder Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingefügt. Im folgenden Beispiel wird das Muster für reguläre Ausdrücke \d+ verwendet, um eine Eingabezeichenfolge auf numerische Zeichen aufzuteilen. Da die Zeichenfolge mit übereinstimmenden numerischen Zeichen beginnt und endet, ist der Wert des ersten und letzten Elements des zurückgegebenen Arrays 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 erfassungsklammern in einem Ausdruck verwendet Regex.Split werden, wird jeder erfasste Text in das resultierende Zeichenfolgenarray eingefügt. Wenn Sie z. B. die Zeichenfolge "plum-pear" auf einen Bindestrich teilen, der in erfassungsklammern platziert ist, enthält das zurückgegebene Array ein Zeichenfolgenelement, das den Bindestrich enthält.

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 Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version des .NET Framework ab. Wenn im .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb des ersten Satzes von Erfassungsklammern gefunden wird, ist erfasster Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird der gesamte erfasste Text dem zurückgegebenen Array hinzugefügt. Im folgenden Code werden beispielsweise zwei Sätze von Erfassungsklammern verwendet, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich, und die zweite Gruppe erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter der .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn sie kompiliert und unter der .NET Framework 2.0 oder höher ausgeführt wird, enthält sie diese.

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 übereinstimmen kann, teilt die Zeichenfolge in ein Array von Zeichenfolgen mit nur einem Zeichen auf, Split(String) da das leere Zeichenfolgentrennzeichen an jeder Stelle gefunden werden kann. Beispiel:

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 Ende des Arrays enthält.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Teilungsvorgangs das vom Konstruktor angegebene Time out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Regex Objekt erstellt wird. Wenn im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne kein Time out definiert ist Regex oder der Time out-Wert ist, Regex.InfiniteMatchTimeout wird keine Ausnahme ausgelöst.

Siehe auch

Gilt für

Split(String, String)

Teilt eine Eingabezeichenfolge an den durch ein reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.

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.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

Gibt zurück

String[]

Ein Array der Zeichenfolgen.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input oder pattern ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

Die Methoden ähneln der -Methode, mit der Ausnahme, dass die Zeichenfolge an einem Trennzeichen aufteilt, das durch einen regulären Ausdruck anstelle einer Gruppe Regex.Split String.Split von Zeichen bestimmt Regex.Split wird. Die input Zeichenfolge wird so oft wie möglich aufgeteilt. Wenn pattern nicht in der Zeichenfolge gefunden input wird, enthält der Rückgabewert ein Element, dessen Wert die ursprüngliche Zeichenfolge input ist.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzreferenz.

Wichtig

Kompilierte reguläre Ausdrücke, die in Aufrufen statischer Methoden Split verwendet werden, werden automatisch zwischengespeichert. Verwenden Sie die Instanzmethoden, um die Lebensdauer kompilierter regulärer Ausdrücke selbst Split zu verwalten.

Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Wenn Sie z. B. eine Zeichenfolge auf einen einzelnen Bindestrich aufteilen, enthält das zurückgegebene Array eine leere Zeichenfolge an der Position, an der zwei angrenzende Bindestriche gefunden werden, wie der folgende Code zeigt.

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 am Anfang oder Ende der Eingabezeichenfolge eine Übereinstimmung gefunden wird, wird am Anfang oder Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. Im folgenden Beispiel wird das Muster für reguläre Ausdrücke verwendet, \d+ um eine Eingabezeichenfolge auf numerische Zeichen zu unterteilen. Da die Zeichenfolge mit übereinstimmenden numerischen Zeichen beginnt und endet, ist der Wert des ersten und letzten Elements des zurückgegebenen Arrays 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 Ausdruck verwendet wird, wird jeder erfasste Regex.Split Text in das resultierende Zeichenfolgenarray eingeschlossen. Wenn Sie z. B. die Zeichenfolge "plum-pear" auf einen Bindestrich teilen, der in Klammern gesetzt ist, enthält das zurückgegebene Array ein Zeichenfolgenelement, das den Bindestrich enthält.

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 Erfassungsklammern enthält, hängt das Verhalten dieser Methode von der Version der .NET Framework. Wenn in .NET Framework 1.0 und 1.1 innerhalb des ersten Klammernsatzes keine Übereinstimmung gefunden wird, ist der erfasste Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab der .NET Framework 2.0 wird auch der erfasste Text dem zurückgegebenen Array hinzugefügt. Der folgende Code verwendet beispielsweise zwei Sätze von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von erfassenden Klammern erfasst den Bindestrich, und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter der .NET Framework 1.0 oder 1.1 ausgeführt wird, werden die Schrägstriche ausgeschlossen. Wenn sie kompiliert und unter der Version .NET Framework 2.0 oder höher ausgeführt wird, enthält sie diese.

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 übereinstimmen kann, teilt die Zeichenfolge in ein Array von Zeichenfolgen mit nur einem Zeichen auf, da das leere Zeichenfolgentrennzeichen an jeder Position Split gefunden werden kann. Beispiel:

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 Ende des Arrays enthält.

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des Teilungsvorgang das time out-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der RegexMatchTimeoutException die Methode aufgerufen wird. Wenn kein Time out in den Eigenschaften der Anwendungsdomäne definiert ist oder der Time out-Wert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Bei dieser Methode kommt es nach einem Intervall zu einem Time out, das dem Standardzeitwert der Anwendungsdomäne entspricht, in der die Methode aufgerufen wird. Wenn für die Anwendungsdomäne kein Time out-Wert definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Time out erfolgt. Die empfohlene statische Methode zum Aufteilen von Text nach einer Muster übereinstimmung ist , mit der Split(String, String, RegexOptions, TimeSpan) Sie das Time out-Intervall festlegen können.

Siehe auch

Gilt für