Regex.Split Methode

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

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

Gibt zurück

Ein Zeichenfolgenarray.

Ausnahmen

Hinweise

Die Regex.Split Methoden ähneln der String.Split(Char[])-Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen teilt, das durch einen regulären Ausdruck bestimmt wird, anstelle einer Reihe von Zeichen. 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 zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions und Regular Expression Language – Kurzübersicht.

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

Wenn eine Übereinstimmung am Anfang oder am Ende der Eingabezeichenfolge gefunden wird, wird am Anfang oder am Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. Im folgenden Beispiel wird das Muster für reguläre Ausdrücke [a-z]+ verwendet, um eine Eingabezeichenfolge auf ein beliebiges alphabetisches Groß- oder Kleinbuchstaben aufzuteilen. Da die Zeichenfolge mit übereinstimmenden alphabetischen Zeichen beginnt und endet, wird 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 die Erfassung von Klammern in einem Regex.Split Ausdruck verwendet wird, wird jeder erfasste Text im resultierenden Zeichenfolgenarray enthalten. Wenn Sie beispielsweise die Zeichenfolge "Plum-Pear" auf einen Bindestrich aufteilen, der in Klammern platziert wird, 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 Klammern enthält, hängt das Verhalten dieser Methode von der Version von .NET Framework ab. Wenn in .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassen von Klammern gefunden wird, ist der erfasste Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird auch der zurückgegebene Text hinzugefügt. Der folgende Code verwendet z. B. zwei Gruppen von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter .NET Framework 1.0 oder 1.1 ausgeführt wird, schließt er die Schrägstriche aus; wenn sie kompiliert und unter .NET Framework 2.0 oder höher ausgeführt wird, enthält sie sie.

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 Split die Zeichenfolge in ein Array von einstelligen Zeichenfolgen auf, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann.

Der matchTimeout-Parameter gibt an, wie lange eine Musterabgleichsmethode versucht werden soll, eine Übereinstimmung zu finden, bevor es zu einem Zeitüberschreitung kommt. Das Festlegen eines Timeoutintervalls verhindert, dass reguläre Ausdrücke, die auf übermäßigem Rückverfolgungsvorgang 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 Backtracking-. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standardtimeoutwert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Hinweise für Aufrufer

Es wird empfohlen, den parameter matchTimeout auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie InfiniteMatchTimeoutangeben, bietet das Modul für reguläre Ausdrücke etwas bessere Leistung. Sie sollten Timeouts jedoch nur unter den folgenden Bedingungen deaktivieren:

• 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 dynamisch von Benutzern eingegeben wurde.

• Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, Nicht-Übereinstimmungen und nahe Übereinstimmungen effizient verarbeitet.

• Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen zu übermäßigem Rückverfolgungsverhalten bei der Verarbeitung einer Nahübereinstimmung führen.

Weitere Informationen

• Elemente der Sprache für reguläre Ausdrücke

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

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

Gibt zurück

Ein Array von Zeichenfolgen.

Ausnahmen

Hinweise

Die Regex.Split Methoden ähneln der String.Split(Char[])-Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen teilt, das durch einen regulären Ausdruck bestimmt wird, anstelle einer Reihe von Zeichen. 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 zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions und Regular Expression Language – Kurzübersicht.

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

Wenn eine Übereinstimmung am Anfang oder am Ende der Eingabezeichenfolge gefunden wird, wird am Anfang oder am Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. Im folgenden Beispiel wird das Muster für reguläre Ausdrücke [a-z]+ verwendet, um eine Eingabezeichenfolge auf ein beliebiges alphabetisches Groß- oder Kleinbuchstaben aufzuteilen. Da die Zeichenfolge mit übereinstimmenden alphabetischen Zeichen beginnt und endet, wird 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 die Erfassung von Klammern in einem Regex.Split Ausdruck verwendet wird, wird jeder erfasste Text im resultierenden Zeichenfolgenarray enthalten. Wenn Sie beispielsweise die Zeichenfolge "Plum-Pear" auf einen Bindestrich aufteilen, der in Klammern platziert wird, 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 Klammern enthält, hängt das Verhalten dieser Methode von der Version von .NET Framework ab. Wenn in .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassen von Klammern gefunden wird, ist der erfasste Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird auch der zurückgegebene Text hinzugefügt. Der folgende Code verwendet z. B. zwei Gruppen von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter .NET Framework 1.0 oder 1.1 ausgeführt wird, schließt er die Schrägstriche aus; wenn sie kompiliert und unter .NET Framework 2.0 oder höher ausgeführt wird, enthält sie sie.

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 Split die Zeichenfolge in ein Array von einstelligen Zeichenfolgen auf, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des geteilten Vorgangs das für die Anwendungsdomäne angegebene Timeoutintervall überschreitet, in dem die Methode aufgerufen wird. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist oder der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Diese Methode timeout nach einem Intervall, das dem Standardtimeoutwert der Anwendungsdomäne entspricht, in der die Methode aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, wodurch verhindert wird, dass die Methode einen Timeoutzeitpunkt erhält. Die empfohlene statische Methode zum Aufteilen von Text in einer Mustervergleichsart ist Split(String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

• Elemente der Sprache für reguläre Ausdrücke

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

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

Gibt zurück

Ein Array von Zeichenfolgen.

Ausnahmen

Hinweise

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

Weitere Informationen zu startatfinden Sie im Abschnitt "Hinweise" von Match(String, Int32).

Wenn keine Übereinstimmungen aus der count+1-Position in der Zeichenfolge gefunden werden, gibt die Methode ein Einelementarray zurück, das die input Zeichenfolge enthält. Wenn mindestens eine Übereinstimmung gefunden wird, 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 der gefundenen Übereinstimmungen mindestens zwei kleiner als countist, wird eine leere Zeichenfolge in das Array eingefügt. Wenn bei startateine Übereinstimmung gefunden wird, bei der es sich um das erste Zeichen in der Zeichenfolge handelt, ist das erste Element des zurückgegebenen Arrays eine leere Zeichenfolge. Das heißt, leere Zeichenfolgen, die aus benachbarten Übereinstimmungen resultieren, werden in der Bestimmung ermittelt, ob die Anzahl der übereinstimmenden Teilzeichenfolgen countentspricht. Im folgenden Beispiel wird der reguläre Ausdruck \d+ verwendet, um die Anfangsposition der ersten Teilzeichenfolge numerischer Zeichen in einer Zeichenfolge zu finden und dann die Zeichenfolge maximal dreimal zu teilen, beginnend an dieser Position. Da das Muster für reguläre Ausdrücke mit dem Anfang der Eingabezeichenfolge übereinstimmt, besteht das zurückgegebene Zeichenfolgenarray aus einer leeren Zeichenfolge, einer fünfstelligen alphabetischen Zeichenfolge 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 die Erfassung von Klammern in einem regulären Ausdruck verwendet wird, wird jeder erfasste Text in das Array geteilter Zeichenfolgen eingeschlossen. Arrayelemente, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der Übereinstimmungen counterreicht wurde. Beispielsweise führt das Aufteilen der Zeichenfolge "apple-apricot-plum-pear-pomegranate-pineapple-peach" in maximal vier Teilzeichenfolgen ab Zeichen 15 in der Zeichenfolge zu einem Siebenelementarray, 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-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 Klammern enthält, hängt das Verhalten dieser Methode von der Version von .NET Framework ab. Wenn in .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassen von Klammern gefunden wird, ist der erfasste Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird auch der zurückgegebene Text hinzugefügt. Der folgende Code verwendet beispielsweise zwei Gruppen 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 Balken. Wenn der Beispielcode kompiliert und unter .NET Framework 1.0 oder 1.1 ausgeführt wird, schließt er die vertikalen Balkenzeichen aus. wenn sie kompiliert und unter .NET Framework 2.0 oder höher ausgeführt wird, enthält sie sie.

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 Split die Zeichenfolge in ein Array von einstelligen Zeichenfolgen auf, da das leere Zeichenfolgentrennzeichen an jeder Position 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 mit dem Ende der Eingabezeichenfolge übereinstimmt, 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 RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des geteilten Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan)-Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex-Objekt erstellt wird. Wenn kein Timeout im Regex-Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Weitere Informationen

• Sprache für reguläre Ausdrücke – Kurzübersicht

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

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

Gibt zurück

Ein Array von Zeichenfolgen.

Ausnahmen

Hinweise

Die Regex.Split Methoden ähneln der String.Split-Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen teilt, das durch einen regulären Ausdruck bestimmt wird, anstelle einer Reihe von Zeichen. Die input Zeichenfolge wird so oft wie möglich geteilt. Wenn pattern in der input Zeichenfolge nicht 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 zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions und Regular Expression Language – Kurzübersicht.

Wenn mehrere Übereinstimmungen nebeneinander liegen, wird eine leere Zeichenfolge in das Array eingefügt. Das Aufteilen einer Zeichenfolge auf einen einzelnen Bindestrich bewirkt beispielsweise, 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()
   {
      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 Übereinstimmung am Anfang oder am Ende der Eingabezeichenfolge gefunden wird, wird am Anfang oder am Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. 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, wird 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 die Erfassung von Klammern in einem Regex.Split Ausdruck verwendet wird, wird jeder erfasste Text im resultierenden Zeichenfolgenarray enthalten. Wenn Sie beispielsweise die Zeichenfolge "Plum-Pear" auf einen Bindestrich aufteilen, der in Klammern platziert wird, 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 Klammern enthält, hängt das Verhalten dieser Methode von der Version von .NET Framework ab. Wenn in .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassen von Klammern gefunden wird, ist der erfasste Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird auch der zurückgegebene Text hinzugefügt. Der folgende Code verwendet z. B. zwei Gruppen von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter .NET Framework 1.0 oder 1.1 ausgeführt wird, schließt er die Schrägstriche aus; wenn sie kompiliert und unter .NET Framework 2.0 oder höher ausgeführt wird, enthält sie sie.

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 Split die Zeichenfolge in ein Array von einstelligen Zeichenfolgen auf, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann. Zum 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 RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des geteilten Vorgangs das für die Anwendungsdomäne angegebene Timeoutintervall überschreitet, in dem die Methode aufgerufen wird. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist oder der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Diese Methode timeout nach einem Intervall, das dem Standardtimeoutwert der Anwendungsdomäne entspricht, in der die Methode aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, wodurch verhindert wird, dass die Methode einen Timeoutzeitpunkt erhält. Die empfohlene statische Methode zum Aufteilen von Text in einer Mustervergleichsart ist Split(String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

• Elemente der Sprache für reguläre Ausdrücke

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

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

Gibt zurück

Ein Array von Zeichenfolgen.

Ausnahmen

Hinweise

Die Regex.Split Methoden ähneln der String.Split(Char[])-Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen teilt, das durch einen regulären Ausdruck bestimmt wird, anstelle einer Reihe von Zeichen. 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. Das Aufteilen einer Zeichenfolge auf einen einzelnen Bindestrich bewirkt beispielsweise, 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 eine Übereinstimmung am Anfang oder am Ende der Eingabezeichenfolge gefunden wird, wird am Anfang oder am Ende des zurückgegebenen Arrays eine leere Zeichenfolge eingeschlossen. 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, wird 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 die Erfassung von Klammern in einem Regex.Split Ausdruck verwendet wird, wird jeder erfasste Text im resultierenden Zeichenfolgenarray enthalten. Wenn Sie beispielsweise die Zeichenfolge "Plum-Pear" auf einen Bindestrich aufteilen, der in Klammern platziert wird, 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 Klammern enthält, hängt das Verhalten dieser Methode von der Version von .NET Framework ab. Wenn in .NET Framework 1.0 und 1.1 keine Übereinstimmung innerhalb der ersten Gruppe von Erfassen von Klammern gefunden wird, ist der erfasste Text aus zusätzlichen Erfassungsklammern nicht im zurückgegebenen Array enthalten. Ab .NET Framework 2.0 wird auch der zurückgegebene Text hinzugefügt. Der folgende Code verwendet z. B. zwei Gruppen von Erfassungsklammern, um die Elemente eines Datums, einschließlich der Datumstrennzeichen, aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich und der zweite Satz erfasst den Schrägstrich. Wenn der Beispielcode kompiliert und unter .NET Framework 1.0 oder 1.1 ausgeführt wird, schließt er die Schrägstriche aus; wenn sie kompiliert und unter .NET Framework 2.0 oder höher ausgeführt wird, enthält sie sie.

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 Split(String) die Zeichenfolge in ein Array von einstelligen Zeichenfolgen auf, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann. Zum 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 geteilten Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan)-Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex-Objekt erstellt wird. Wenn kein Timeout im Regex-Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Weitere Informationen

• Sprache für reguläre Ausdrücke – Kurzübersicht

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

Quelle:

Regex.Split.cs

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

Gibt zurück

Ein Array von Zeichenfolgen.

Ausnahmen

Hinweise

Die Regex.Split Methoden ähneln der String.Split-Methode, mit der Ausnahme, dass Regex.Split die Zeichenfolge an einem Trennzeichen teilt, das durch einen regulären Ausdruck bestimmt wird, anstelle einer Reihe von Zeichen. Der parameter count gibt die maximale Anzahl von Teilzeichenfolgen an, in die die input Zeichenfolge aufgeteilt werden kann; die letzte Zeichenfolge enthält den nicht multiplizierten Rest der Zeichenfolge. Ein count Nullwert stellt das Standardverhalten der Aufteilung so oft wie möglich bereit.

Wenn mehrere Übereinstimmungen nebeneinander liegen oder eine Übereinstimmung am Anfang oder Ende der inputgefunden wird und die Anzahl der gefundenen Übereinstimmungen mindestens zwei kleiner als countist, wird eine leere Zeichenfolge in das Array eingefügt. Das heißt, leere Zeichenfolgen, die aus benachbarten Übereinstimmungen oder aus Übereinstimmungen am Anfang oder Ende der Eingabezeichenfolge resultieren, werden gezählt, um zu bestimmen, ob die Anzahl der übereinstimmenden Teilzeichenfolgen gleich countist. Im folgenden Beispiel wird der reguläre Ausdruck /d+ verwendet, um eine Eingabezeichenfolge aufzuteilen, die eine oder mehrere Dezimalziffern in maximal drei Teilzeichenfolgen enthält. Da der Anfang der Eingabezeichenfolge dem Muster des regulären Ausdrucks entspricht, enthält das erste Arrayelement String.Empty, der zweite enthält den ersten Satz alphabetischer Zeichen in der Eingabezeichenfolge, und der 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 geteilter Zeichenfolgen eingeschlossen. Arrayelemente, die erfassten Text enthalten, werden jedoch nicht gezählt, um zu bestimmen, ob die Anzahl der Übereinstimmungen counterreicht wurde. Beispielsweise führt das Aufteilen der Zeichenfolge "apple-apricot-plum-pear-banana" in maximal vier Teilzeichenfolgen zu einem Sieben-Element-Array, 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 Klammern enthält, hängt das Verhalten dieser Methode von der Version von .NET Framework ab. In .NET Framework 1.0 und 1.1 wird nur der erste Satz von Erfassungsklammern in das zurückgegebene Array aufgenommen. Ab .NET Framework 2.0 wird dem zurückgegebenen Array der gesamte erfasste Text 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 countentspricht. Im folgenden Code verwendet ein regulärer Ausdruck beispielsweise zwei Gruppen von Erfassungsklammern, um die Elemente eines Datums aus einer Datumszeichenfolge zu extrahieren. Der erste Satz von Erfassungsklammern erfasst den Bindestrich und der zweite Satz 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 .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 .NET Framework 2.0 oder höher ausgeführt wird, gibt die Methode ein Zeichenfolgenarray 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 Split(String, Int32) die Zeichenfolge in ein Array von einstelligen Zeichenfolgen auf, da das leere Zeichenfolgentrennzeichen an jeder Position gefunden werden kann. Im folgenden Beispiel wird die Zeichenfolge "characters" in so viele Elemente wie in der Eingabezeichenfolge aufgeteilt. Da die NULL-Zeichenfolge mit dem Anfang der Eingabezeichenfolge übereinstimmt, 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 RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des geteilten Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan)-Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der das Regex-Objekt erstellt wird. Wenn kein Timeout im Regex-Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Weitere Informationen

• Sprache für reguläre Ausdrücke – Kurzübersicht