Freigeben über

Das Objektmodell für reguläre Ausdrücke

  • Artikel

In diesem Artikel wird das Objektmodell beschrieben, das beim Arbeiten mit regulären .NET-Ausdrücken verwendet wird.

Die Engine für reguläre Ausdrücke

Die Engine für reguläre Ausdrücke in .NET wird durch die Regex-Klasse dargestellt. Die Engine für reguläre Ausdrücke ist für das Analysieren und Kompilieren eines regulären Ausdrucks sowie für das Ausführen von Vorgängen zuständig, die dem Muster eines regulären Ausdrucks mit einer Eingabezeichenfolge entsprechen. Die Engine ist die zentrale Komponente im .NET-Objektmodell für reguläre Ausdrücke.

Die Engine für reguläre Ausdrücke kann auf zwei verschiedene Arten verwendet werden:

  • Durch Aufrufen der statischen Methoden der Regex-Klasse. Die Methodenparameter schließen die Eingabezeichenfolge und das Muster eines regulären Ausdrucks ein. Die Engine für reguläre Ausdrücke führt eine Zwischenspeicherung der regulären Ausdrücke aus, die in statischen Methodenaufrufen verwendet werden. Daher zeigen wiederholte Aufrufe von statischen regulären Ausdrucksmethoden, für die der gleiche reguläre Ausdruck verwendet wird, eine relativ gute Leistung.

  • Durch Instanziieren eines Regex-Objekts, nämlich durch Übergeben eines regulären Ausdrucks an den Klassenkonstruktor. In diesem Fall ist das Regex-Objekt unveränderlich (schreibgeschützt) und stellt eine Engine für reguläre Ausdrücke dar, das eng an einen einzelnen regulären Ausdruck gekoppelt ist. Da von Regex-Instanzen verwendete reguläre Ausdrücke nicht zwischengespeichert werden, sollte ein Regex-Objekt nicht mehrmals mit dem gleichen regulären Ausdruck instanziiert werden.

Sie können die Methoden der Regex-Klasse aufrufen, um die folgenden Vorgänge auszuführen:

  • Bestimmen, ob eine Zeichenfolge mit einem Muster eines regulären Ausdrucks übereinstimmt.
  • Extrahieren einer einzelnen Übereinstimmung oder der ersten Übereinstimmung.
  • Extrahieren aller Übereinstimmungen.
  • Ersetzen einer übereinstimmenden Teilzeichenfolge.
  • Teilen einer einzelnen Zeichenfolge in ein Zeichenfolgenarray.

Diese Vorgänge werden in den folgenden Abschnitten beschrieben.

Ein Muster mit regulären Ausdrücken übereinstimmen

Von der Regex.IsMatch-Methode wird true zurückgegeben, falls die Zeichenfolge mit dem Muster übereinstimmt, bzw. false, wenn dies nicht der Fall ist. Die IsMatch-Methode wird häufig dazu verwendet, um Zeichenfolgeneingaben zu überprüfen. Durch den folgende Code wird z. B. sichergestellt, dass eine Zeichenfolge mit einer gültigen Sozialunterstützungsnummer in den USA übereinstimmt.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] values = { "111-22-3333", "111-2-3333"};
      string pattern = @"^\d{3}-\d{2}-\d{4}$";
      foreach (string value in values) {
         if (Regex.IsMatch(value, pattern))
            Console.WriteLine("{0} is a valid SSN.", value);
         else
            Console.WriteLine("{0}: Invalid", value);
      }
   }
}
// The example displays the following output:
//       111-22-3333 is a valid SSN.
//       111-2-3333: Invalid

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim values() As String = {"111-22-3333", "111-2-3333"}
        Dim pattern As String = "^\d{3}-\d{2}-\d{4}$"
        For Each value As String In values
            If Regex.IsMatch(value, pattern) Then
                Console.WriteLine("{0} is a valid SSN.", value)
            Else
                Console.WriteLine("{0}: Invalid", value)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111-22-3333 is a valid SSN.
'       111-2-3333: Invalid

Das Muster für reguläre Ausdrücke ^\d{3}-\d{2}-\d{4}$ wird entsprechend der folgenden Tabelle interpretiert:

Muster Beschreibung
^ Entsprechung für den Anfang der Eingabezeichenfolge finden.
\d{3} Entsprechung für drei Dezimalstellen finden.
- Entsprechung für einen Bindestrich finden.
\d{2} Entsprechung für zwei Dezimalstellen finden.
- Entsprechung für einen Bindestrich finden.
\d{4} Entsprechung für vier Dezimalstellen finden.
$ Entsprechung für das Ende der Eingabezeichenfolge finden.

Extrahieren einer einzelnen Übereinstimmung oder der ersten Übereinstimmung

Von der Regex.Match-Methode wird ein Match-Objekt zurückgegeben, das Informationen zur ersten Teilzeichenfolge enthält, die mit einem Muster eines regulären Ausdrucks übereinstimmt. Wenn die Match.Success-Eigenschaft true zurückgibt und angibt, dass eine Übereinstimmung gefunden wurde, können Sie Informationen zu nachfolgenden Übereinstimmungen abrufen, indem Sie die Match.NextMatch-Methode aufrufen. Diese Methodenaufrufe können fortgesetzt werden, bis die Match.Success-Eigenschaft false zurückgibt. Im folgenden Code wird zum Beispiel mithilfe der Regex.Match(String, String)-Methode das erste Vorkommen eines doppelt vorhandenen Worts in einer Zeichenfolge gesucht. Anschließend wird die Match.NextMatch-Methode aufgerufen, um zusätzliche Vorkommen zu suchen. Im Beispiel wird die Match.Success-Eigenschaft nach jedem Methodenaufruf überprüft, um zu bestimmen, ob die aktuelle Übereinstimmung erfolgreich war, und ob ein Aufruf der Match.NextMatch-Methode folgen soll.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle.";
      string pattern = @"\b(\w+)\W+(\1)\b";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("Duplicate '{0}' found at position {1}.",
                           match.Groups[1].Value, match.Groups[2].Index);
         match = match.NextMatch();
      }
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is a a farm that that raises dairy cattle."
        Dim pattern As String = "\b(\w+)\W+(\1)\b"
        Dim match As Match = Regex.Match(input, pattern)
        Do While match.Success
            Console.WriteLine("Duplicate '{0}' found at position {1}.", _
                              match.Groups(1).Value, match.Groups(2).Index)
            match = match.NextMatch()
        Loop
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

Das Muster für reguläre Ausdrücke \b(\w+)\W+(\1)\b wird entsprechend der folgenden Tabelle interpretiert:

Muster Beschreibung
\b Beginnt den Vergleich an einer Wortgrenze.
(\w+) Übereinstimmung mit mindestens einem Wortzeichen. Dies ist die erste Erfassungsgruppe.
\W+ Entsprechung für mindestens ein Nicht-Wortzeichen finden.
(\1) Entsprechung für die erste erfasste Zeichenfolge finden. Dies ist die zweite Erfassungsgruppe.
\b Beendet den Vergleich an einer Wortgrenze.

Extrahieren aller Übereinstimmungen

Von der Regex.Matches-Methode wird ein MatchCollection-Objekt zurückgegeben, das Informationen zu allen Übereinstimmungen enthält, die von der Engine für reguläre Ausdrücke in der Eingabezeichenfolge gefunden wurden. Zum Beispiel kann das vorherige Beispiel neu geschrieben werden, um die Matches-Methode anstelle der Match-Methode und der NextMatch-Methode aufzurufen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle.";
      string pattern = @"\b(\w+)\W+(\1)\b";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Duplicate '{0}' found at position {1}.",
                           match.Groups[1].Value, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "This is a a farm that that raises dairy cattle."
        Dim pattern As String = "\b(\w+)\W+(\1)\b"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Duplicate '{0}' found at position {1}.", _
                              match.Groups(1).Value, match.Groups(2).Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

Ersetzen einer übereinstimmenden Teilzeichenfolge

Die Regex.Replace-Methode ersetzt jede Teilzeichenfolge, die mit dem Muster eines regulären Ausdrucks mit einer angegebenen Zeichenfolge oder einem Muster eines regulären Ausdrucks übereinstimmt, und gibt die gesamte Eingabezeichenfolge mit Ersetzungen zurück. Beispielsweise fügt der folgende Code ein US-Währungssymbol vor einer Dezimalzahl in einer Zeichenfolge hinzu.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+\.\d{2}\b";
      string replacement = "$$$&";
      string input = "Total Cost: 103.64";
      Console.WriteLine(Regex.Replace(input, pattern, replacement));
   }
}
// The example displays the following output:
//       Total Cost: $103.64

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\d+\.\d{2}\b"
        Dim replacement As String = "$$$&"
        Dim input As String = "Total Cost: 103.64"
        Console.WriteLine(Regex.Replace(input, pattern, replacement))
    End Sub
End Module
' The example displays the following output:
'       Total Cost: $103.64

Das Muster für reguläre Ausdrücke \b\d+\.\d{2}\b wird entsprechend der folgenden Tabelle interpretiert:

Muster Beschreibung
\b Der Vergleich beginnt an einer Wortgrenze.
\d+ Entsprechung für mindestens eine Dezimalstelle finden.
\. Entsprechung für einen Punkt finden.
\d{2} Entsprechung für zwei Dezimalstellen finden.
\b Der Vergleich endet an einer Wortgrenze.

Das Ersetzungsmuster $$$& wird gemäß der Darstellung in der folgenden Tabelle interpretiert.

Muster Ersetzungszeichenfolge
$$ Das Dollarzeichen ($).
$& Die gesamte abgeglichene Teilzeichenfolge.

Teilen einer einzelnen Zeichenfolge in ein Zeichenfolgenarray

Mit der Regex.Split-Methode wird die Eingabezeichenfolge an den Stellen aufgeteilt, die durch eine Übereinstimmung bei einem regulären Ausdruck definiert wurde. Im folgenden Code werden z. B. die Elemente in ein Zeichenfolgenarray in einer nummerierten Liste eingefügt.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
      string pattern = @"\b\d{1,2}\.\s";
      foreach (string item in Regex.Split(input, pattern))
      {
         if (! String.IsNullOrEmpty(item))
            Console.WriteLine(item);
      }
   }
}
// The example displays the following output:
//       Eggs
//       Bread
//       Milk
//       Coffee
//       Tea

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea"
        Dim pattern As String = "\b\d{1,2}\.\s"
        For Each item As String In Regex.Split(input, pattern)
            If Not String.IsNullOrEmpty(item) Then
                Console.WriteLine(item)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       Eggs
'       Bread
'       Milk
'       Coffee
'       Tea

Das Muster für reguläre Ausdrücke \b\d{1,2}\.\s wird entsprechend der folgenden Tabelle interpretiert:

Muster Beschreibung
\b Der Vergleich beginnt an einer Wortgrenze.
\d{1,2} Entsprechung für eine oder zwei Dezimalstellen finden.
\. Entsprechung für einen Punkt finden.
\s Entsprechung für ein Leerraumzeichen finden.

Die Objekte MatchCollection und Match

Regex-Methoden geben zwei Objekte zurück, die Teil des Objektmodells für einen regulären Ausdruck sind: das MatchCollection-Objekt und das Match-Objekt.

Die MatchCollection-Klasse

Die Regex.Matches-Methode gibt ein MatchCollection-Objekt zurück, das Match-Objekte enthält, die alle Übereinstimmungen darstellen, die die Engine für reguläre Ausdrücke gefunden hat, und zwar in der Reihenfolge, in der sie in der Eingabezeichenfolge auftreten. Wenn keine Übereinstimmungen vorhanden sind, gibt die Methode ein MatchCollection-Objekt ohne Member zurück. Die MatchCollection.Item[]-Eigenschaft ermöglicht den Zugriff auf einzelne Member der Auflistung nach Index, von null bis eins weniger als es dem Wert der MatchCollection.Count-Eigenschaft entspricht. Item[] ist der Indexer (in C#) und die Standardeigenschaft der Auflistung (in Visual Basic).

Der Aufruf der Regex.Matches-Methode füllt standardmäßig das MatchCollection-Objekt mithilfe verzögerter Auswertung auf. Zugriff auf Eigenschaften, die eine vollständig aufgefüllte Auflistung erfordern, z. B. die MatchCollection.Count-Eigenschaft und die MatchCollection.Item[]-Eigenschaft, führt möglicherweise zu Leistungseinbußen. Daher wird empfohlen, dass Sie auf die Auflistung mit dem IEnumerator-Objekt zugreifen, das von der MatchCollection.GetEnumerator-Methode zurückgegeben wird. Einzelne Sprachen stellen Konstrukte bereit, z.B. For Each in Visual Basic und foreach in C#, die die IEnumerator-Schnittstelle der Auflistung umschließen.

Im folgenden Beispiel wird mithilfe der Regex.Matches(String)-Methode ein MatchCollection-Objekt mit sämtlichen Übereinstimmungen aufgefüllt, die in einer Eingabezeichenfolge gefunden wurden. Im Beispiel wird die Auflistung aufgeführt, die Übereinstimmungen werden in ein Zeichenfolgenarray kopiert, und die Zeichenpositionen werden in einem ganzzahligen Array erfasst.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
       MatchCollection matches;
       List<string> results = new List<string>();
       List<int> matchposition = new List<int>();

       // Create a new Regex object and define the regular expression.
       Regex r = new Regex("abc");
       // Use the Matches method to find all matches in the input string.
       matches = r.Matches("123abc4abcd");
       // Enumerate the collection to retrieve all matches and positions.
       foreach (Match match in matches)
       {
          // Add the match string to the string array.
           results.Add(match.Value);
           // Record the character position where the match was found.
           matchposition.Add(match.Index);
       }
       // List the results.
       for (int ctr = 0; ctr < results.Count; ctr++)
         Console.WriteLine("'{0}' found at position {1}.",
                           results[ctr], matchposition[ctr]);
   }
}
// The example displays the following output:
//       'abc' found at position 3.
//       'abc' found at position 7.

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim matches As MatchCollection
        Dim results As New List(Of String)
        Dim matchposition As New List(Of Integer)

        ' Create a new Regex object and define the regular expression.
        Dim r As New Regex("abc")
        ' Use the Matches method to find all matches in the input string.
        matches = r.Matches("123abc4abcd")
        ' Enumerate the collection to retrieve all matches and positions.
        For Each match As Match In matches
            ' Add the match string to the string array.
            results.Add(match.Value)
            ' Record the character position where the match was found.
            matchposition.Add(match.Index)
        Next
        ' List the results.
        For ctr As Integer = 0 To results.Count - 1
            Console.WriteLine("'{0}' found at position {1}.", _
                              results(ctr), matchposition(ctr))
        Next
    End Sub
End Module
' The example displays the following output:
'       'abc' found at position 3.
'       'abc' found at position 7.

Die Match-Klasse

Die Match-Klasse stellt das Ergebnis einer einzelnen regulären Ausdrucksübereinstimmung dar. Es gibt zwei Möglichkeiten für den Zugriff auf Match-Objekte:

  • Sie können von dem MatchCollection-Objekt abgerufen werden, das von der Regex.Matches-Methode zurückgegeben wird. Um einzelne Match-Objekte abzurufen, durchlaufen Sie die Auflistung mit einem foreach-Konstrukt (in C#) oder einem For Each...Next-Konstrukt (in Visual Basic), oder rufen Sie mithilfe der MatchCollection.Item[]-Eigenschaft ein bestimmtes Match-Objekt Objekt nach Index oder Name ab. Sie können auch einzelne Match-Objekte aus der Auflistung abrufen, indem Sie die Auflistung nach dem Index durchlaufen, von 0 (null) bis eins weniger, als es der Anzahl der Objekte in der Auflistung entspricht. Bei dieser Methode wird jedoch keine verzögerte Auswertung genutzt, da dabei auf die MatchCollection.Count-Eigenschaft zugegriffen wird.

    Im folgenden Beispiel werden einzelne Match-Objekte aus einem MatchCollection-Objekt abgerufen, indem die Auflistung mit einem foreach- oder For Each...Next-Konstrukt durchlaufen wird. Der reguläre Ausdruck stimmt mit der Zeichenfolge "abc" in der Eingabezeichenfolge überein.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "abc";
      string input = "abc123abc456abc789";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("{0} found at position {1}.",
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       abc found at position 0.
//       abc found at position 6.
//       abc found at position 12.

    Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "abc"
        Dim input As String = "abc123abc456abc789"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("{0} found at position {1}.", _
                              match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       abc found at position 0.
'       abc found at position 6.
'       abc found at position 12.

  • Durch Aufrufen der Regex.Match-Methode, die ein Match-Objekt zurückgibt, das die erste Übereinstimmung in einer Zeichenfolge oder einem Teil einer Zeichenfolge darstellt. Sie können bestimmen, ob die Übereinstimmung gefunden wurde, indem der Wert der Match.Success-Eigenschaft abgerufen wird. Um Match-Objekte abzurufen, die nachfolgende Übereinstimmungen darstellen, rufen Sie die Match.NextMatch-Methode wiederholt auf, bis die Success-Eigenschaft des zurückgegebenen Match-Objekts false ist.

    Im folgenden Beispiel werden die Regex.Match(String, String)-Methode und die Match.NextMatch-Methode verwendet, um die Zeichenfolge "abc" in der Eingabezeichenfolge abzugleichen.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "abc";
      string input = "abc123abc456abc789";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("{0} found at position {1}.",
                           match.Value, match.Index);
         match = match.NextMatch();
      }
   }
}
// The example displays the following output:
//       abc found at position 0.
//       abc found at position 6.
//       abc found at position 12.

    Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "abc"
        Dim input As String = "abc123abc456abc789"
        Dim match As Match = Regex.Match(input, pattern)
        Do While match.Success
            Console.WriteLine("{0} found at position {1}.", _
                              match.Value, match.Index)
            match = match.NextMatch()
        Loop
    End Sub
End Module
' The example displays the following output:
'       abc found at position 0.
'       abc found at position 6.
'       abc found at position 12.

Zwei Eigenschaften der Match-Klasse geben Auflistungsobjekte zurück:

  • Die Match.Groups-Eigenschaft gibt ein GroupCollection-Objekt zurück, das Informationen zu den Teilzeichenfolgen enthält, die mit Erfassungsgruppen im Muster eines regulären Ausdrucks übereinstimmen.

  • Die Match.Captures-Eigenschaft gibt ein CaptureCollection-Objekt mit eingeschränkter Verwendung zurück. Die Auflistung wird nicht für ein Match-Objekt aufgefüllt, dessen Success-Eigenschaft false ist. Andernfalls enthält es ein einzelnes Capture-Objekt, das über die gleichen Informationen wie das Match-Objekt verfügt.

Weitere Informationen zu diesen Objekten finden Sie in den Abschnitten der GroupCollectionKlasse und Der CaptureCollection-Klasse weiter unten in diesem Artikel.

Zwei zusätzliche Eigenschaften der Match-Klasse stellen Informationen zur Übereinstimmung bereit. Die Match.Value-Eigenschaft gibt die Teilzeichenfolge in der Eingabezeichenfolge zurück, die mit dem Muster eines regulären Ausdrucks übereinstimmt. Die Match.Index-Eigenschaft gibt die nullbasierte Anfangsposition der entsprechenden Zeichenfolge in der Eingabezeichenfolge zurück.

Die Match-Klasse besitzt ebenfalls zwei Methoden zum Mustervergleich:

  • Die Match.NextMatch-Methode sucht die Übereinstimmung nach der Übereinstimmung, die durch das aktuelle Match-Objekt dargestellt wird, und gibt ein Match-Objekt zurück, das diese Übereinstimmung darstellt.

  • Die Match.Result-Methode führt einen angegebenen Ersetzungsvorgang in der entsprechenden Zeichenfolge aus und gibt das Ergebnis zurück.

Im folgenden Beispiel werden mit der Match.Result-Methode jeder Zahl, die zwei Bruchzahlen enthält, ein $-Symbol und ein Leerzeichen vorangestellt.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
      string input = "16.32\n194.03\n1,903,672.08";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Result("$$ $&"));
   }
}
// The example displays the following output:
//       $ 16.32
//       $ 194.03
//       $ 1,903,672.08

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\d+(,\d{3})*\.\d{2}\b"
        Dim input As String = "16.32" + vbCrLf + "194.03" + vbCrLf + "1,903,672.08"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Result("$$ $&"))
        Next
    End Sub
End Module
' The example displays the following output:
'       $ 16.32
'       $ 194.03
'       $ 1,903,672.08

Das Muster für reguläre Ausdrücke \b\d+(,\d{3})*\.\d{2}\b wird entsprechend der folgenden Tabelle definiert:

Muster Beschreibung
\b Der Vergleich beginnt an einer Wortgrenze.
\d+ Entsprechung für mindestens eine Dezimalstelle finden.
(,\d{3})* Entsprechung für null oder mehr Vorkommen eines Kommas finden, auf das Dezimalstellen folgen.
\. Entsprechung für das Dezimaltrennzeichenzeichen finden.
\d{2} Entsprechung für zwei Dezimalstellen finden.
\b Der Vergleich endet an einer Wortgrenze.

Der Ersatzmuster-$$ $& gibt an, dass die übereinstimmende Teilzeichenfolge durch ein Dollarzeichensymbol ($) (das $$-Muster), ein Leerzeichen und den Wert der Übereinstimmung (das $&-Muster) ersetzt werden soll.

Die GroupCollection-Klasse

Die Match.Groups-Eigenschaft gibt ein GroupCollection-Objekt zurück, das Group-Objekte enthält, die erfasste Gruppen in einer einzelnen Übereinstimmung darstellen. Das erste Group-Objekt in der Auflistung (an Index 0) stellt die gesamte Übereinstimmung dar. Jedes Objekt, das folgt, stellt die Ergebnisse einer einzelnen Erfassungsgruppe dar.

Sie können einzelne Group-Objekte in der Auflistung mit der GroupCollection.Item[]-Eigenschaft abrufen. Sie können unbenannte Gruppen durch ihre Ordnungsposition in der Auflistung abrufen und benannte Gruppen entweder nach dem Namen oder nach der Ordnungsposition abrufen. Unbenannte Erfassungen werden zuerst in der Auflistung angezeigt und werden von links nach rechts in der Reihenfolge indiziert, in der sie im Muster eines regulären Ausdrucks angezeigt werden. Benannte Erfassungen werden nach unbenannten Erfassungen von links nach rechts in der Reihenfolge indiziert, in der sie im Muster eines regulären Ausdrucks angezeigt werden. Um festzustellen, welche nummerierten Gruppen in der Auflistung verfügbar sind, die für eine bestimmte Methode für Übereinstimmungen mit regulären Ausdrücken zurückgegeben wird, können Sie die Instanzenmethode Regex.GetGroupNumbers aufrufen. Um festzustellen, welche benannten Gruppen in der Auflistung verfügbar sind, können Sie die Instanzenmethode Regex.GetGroupNames aufrufen. Beide Methoden sind besonders nützlich in Allzweckroutinen, die die von beliebigen regulären Ausdrücken gefundenen Übereinstimmungen analysieren.

Die GroupCollection.Item[]-Eigenschaft ist der Indexer der Auflistung in C# und der Standardeigenschaft des Auflistungsobjekts in Visual Basic. Dies bedeutet, dass auf diese einzelnen Group-Objekte wie folgt nach Index (oder nach Name bei benannten Gruppen) zugegriffen werden kann:

Group group = match.Groups[ctr];

Dim group As Group = match.Groups(ctr)

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, der Gruppierungskonstrukte verwendet, um Monat, Tag und Jahr eines Datums zu erfassen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
      string input = "Born: July 28, 1989";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
         for (int ctr = 0; ctr <  match.Groups.Count; ctr++)
            Console.WriteLine("Group {0}: {1}", ctr, match.Groups[ctr].Value);
    }
}
// The example displays the following output:
//       Group 0: July 28, 1989
//       Group 1: July
//       Group 2: 28
//       Group 3: 1989

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)\s(\d{1,2}),\s(\d{4})\b"
        Dim input As String = "Born: July 28, 1989"
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            For ctr As Integer = 0 To match.Groups.Count - 1
                Console.WriteLine("Group {0}: {1}", ctr, match.Groups(ctr).Value)
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Group 0: July 28, 1989
'       Group 1: July
'       Group 2: 28
'       Group 3: 1989

Das Muster für reguläre Ausdrücke \b(\w+)\s(\d{1,2}),\s(\d{4})\b wird entsprechend der folgenden Tabelle definiert:

Muster Beschreibung
\b Der Vergleich beginnt an einer Wortgrenze.
(\w+) Übereinstimmung mit mindestens einem Wortzeichen. Dies ist die erste Erfassungsgruppe.
\s Entsprechung für ein Leerraumzeichen finden.
(\d{1,2}) Entsprechung für eine oder zwei Dezimalstellen finden. Dies ist die zweite Erfassungsgruppe.
, Entsprechung für ein Komma finden.
\s Entsprechung für ein Leerraumzeichen finden.
(\d{4}) Entsprechung für vier Dezimalstellen finden. Dies ist die dritte Erfassungsgruppe.
\b Beendet den Vergleich an einer Wortgrenze.

Die erfasste Gruppe

Die Group-Klasse stellt das von einer einzelnen Erfassungsgruppe erfassten Ergebnis dar. Gruppenobjekte, die die Erfassungsgruppen darstellen, die in einem regulären Ausdruck definiert werden, werden von der Item[]-Eigenschaft des GroupCollection-Objekts zurückgegeben, das von der Match.Groups-Eigenschaft zurückgegeben wurde. Die Item[]-Eigenschaft ist der Indexer (in C#) und die Standardeigenschaft (in Visual Basic) Group-Klasse. Sie können auch einzelne Member abrufen, indem Sie die Auflistung mit dem foreach- oder dem For Each-Konstrukt durchlaufen. Ein Beispiel finden Sie im vorherigen Abschnitt.

Im folgenden Beispiel werden verschachtelte Gruppierungskonstrukte verwendet, um Teilzeichenfolgen in Gruppen aufzuzeichnen. Das Muster eines regulären Ausdrucks (a(b))c stimmt mit der Zeichenfolge "abc" überein. Es weist die Teilzeichenfolgen "ab" der ersten Erfassungsgruppe und die Teilzeichenfolge "b" der zweiten Erfassungsgruppe zu.

var matchposition = new List<int>();
var results = new List<string>();
// Define substrings abc, ab, b.
var r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
    // Add groups to string array.
    results.Add(m.Groups[i].Value);
    // Record character position.
    matchposition.Add(m.Groups[i].Index);
}

// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
    Console.WriteLine("{0} at position {1}",
                      results[ctr], matchposition[ctr]);
// The example displays the following output:
//       abc at position 3
//       ab at position 3
//       b at position 4

Dim matchposition As New List(Of Integer)
Dim results As New List(Of String)
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
    ' Add groups to string array.
    results.Add(m.Groups(i).Value)
    ' Record character position. 
    matchposition.Add(m.Groups(i).Index)
    i += 1
End While

' Display the capture groups.
For ctr As Integer = 0 to results.Count - 1
    Console.WriteLine("{0} at position {1}", _
                      results(ctr), matchposition(ctr))
Next
' The example displays the following output:
'       abc at position 3
'       ab at position 3
'       b at position 4

Im folgenden Codebeispiel werden benannte Gruppierungskonstrukte verwendet, um Teilzeichenfolgen in einer Zeichenfolge zu erfassen, die Daten im Format "DATENNAME:WERT" enthält. Durch den regulären Ausdruck werden diese am Doppelpunkt (:) getrennt.

var r = new Regex(@"^(?<name>\w+):(?<value>\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
//       Section1
//       119900

Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
'       Section1
'       119900

Das Muster für reguläre Ausdrücke ^(?<name>\w+):(?<value>\w+) wird entsprechend der folgenden Tabelle definiert:

Muster Beschreibung
^ Beginnt den Vergleich am Anfang der Eingabezeichenfolge.
(?<name>\w+) Übereinstimmung mit mindestens einem Wortzeichen. Der Name dieser Erfassungsgruppe ist name.
: Entsprechung für einen Doppelpunkt finden.
(?<value>\w+) Übereinstimmung mit mindestens einem Wortzeichen. Der Name dieser Erfassungsgruppe ist value.

Die Eigenschaften der Group-Klasse enthalten Informationen zur erfassten Gruppe: Die Group.Value-Eigenschaft enthält die erfasste Teilzeichenfolge, die Group.Index-Eigenschaft gibt die Anfangsposition der erfassten Gruppe im Eingabetext an, die Group.Length-Eigenschaft enthält die Länge des erfassten Texts, und die Group.Success-Eigenschaft gibt an, ob eine Teilzeichenfolge dem Muster entsprach, das durch die Erfassungsgruppe definiert wurde.

Durch Anwenden von Quantifizierern auf eine Gruppe (weitere Informationen finden Sie unter Quantifizierer) wird die Beziehung einer Erfassung pro Erfassungsgruppe in zweierlei Hinsicht geändert:

  • Wenn der *-Quantifizierer oder der *?-Quantifizierer (der null oder mehr Übereinstimmungen angibt) für eine Gruppe übernommen wird, verfügt eine Erfassungsgruppe möglicherweise über keine Übereinstimmung in der Eingabezeichenfolge. Wenn kein erfasster Text vorhanden ist, werden die Eigenschaften des Group-Objekts entsprechend der Darstellung in der folgenden Tabelle festgelegt.

    Gruppeneigenschaft Wert
    Success false
    Value String.Empty
    Length 0

    Dies wird im folgenden Beispiel veranschaulicht. Im Muster eines regulären Ausdrucks aaa(bbb)*ccc kann es für die erste Erfassungsgruppe (die Teilzeichenfolge "bbb") null oder mehrere Übereinstimmungen geben. Da die Eingabezeichenfolge "aaaccc" dem Muster entspricht, weist die Erfassungsgruppe keine Übereinstimmung auf.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "aaa(bbb)*ccc";
      string input = "aaaccc";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match value: {0}", match.Value);
      if (match.Groups[1].Success)
         Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value);
      else
         Console.WriteLine("The first capturing group has no match.");
   }
}
// The example displays the following output:
//       Match value: aaaccc
//       The first capturing group has no match.

    Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "aaa(bbb)*ccc"
        Dim input As String = "aaaccc"
        Dim match As Match = Regex.Match(input, pattern)
        Console.WriteLine("Match value: {0}", match.Value)
        If match.Groups(1).Success Then
            Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value)
        Else
            Console.WriteLine("The first capturing group has no match.")
        End If
    End Sub
End Module
' The example displays the following output:
'       Match value: aaaccc
'       The first capturing group has no match.

  • Quantifizierer können mit mehreren Vorkommen eines Musters übereinstimmen, das durch eine Erfassungsgruppe definiert wird. In diesem Fall enthalten die Value-Eigenschaft und die Length-Eigenschaft eines Group-Objekts nur Informationen zur letzten erfassten Teilzeichenfolge. Der folgende reguläre Ausdruck entspricht z. B. einem einzelnen Satz, der mit einem Punkt endet. Es werden zwei Gruppierungskonstrukte verwendet: Mit dem ersten Konstrukt werden einzelne Wörter mit einem Leerstellenzeichen erfasst und mit dem zweiten einzelne Wörter. Wie die Ausgabe des Beispiels zeigt, erfasst die zweite Erfassungsgruppe nur das letzte Wort, obwohl mit dem regulären Ausdruck ein vollständiger Satz erfasst wird.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((\w+)\s?)+\.";
      string input = "This is a sentence. This is another sentence.";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Match: " + match.Value);
         Console.WriteLine("Group 2: " + match.Groups[2].Value);
      }
   }
}
// The example displays the following output:
//       Match: This is a sentence.
//       Group 2: sentence

    Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b((\w+)\s?)+\."
        Dim input As String = "This is a sentence. This is another sentence."
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Match: " + match.Value)
            Console.WriteLine("Group 2: " + match.Groups(2).Value)
        End If
    End Sub
End Module
' The example displays the following output:
'       Match: This is a sentence.
'       Group 2: sentence

Die CaptureCollection-Klasse

Das Group-Objekt enthält nur Informationen zur letzten Erfassung. Allerdings sind alle Erfassungen, die von einer Erfassungsgruppe gemacht wurden, nach wie vor über das CaptureCollection-Objekt verfügbar, das von der Group.Captures-Eigenschaft zurückgegeben wird. Jeder Member der Auflistung ist ein Capture-Objekt, das eine von dieser Erfassungsgruppe gemachte Erfassung darstellt, und zwar in der Reihenfolge, in der sie erfasst wurden (und daher in der Reihenfolge, in der die erfassten Zeichenfolgen von links nach rechts in der Eingabezeichenfolge abgeglichen wurden). Einzelne Capture-Objekte können auf zwei unterschiedliche Arten aus der Auflistung abgerufen werden:

  • Durch das Durchlaufen der Sammlung mit einem Konstrukt wie foreach (in C#) oder For Each (in Visual Basic).

  • Mit der CaptureCollection.Item[]-Eigenschaft, um ein bestimmtes Objekt nach Index abzurufen. Die Item[]-Eigenschaft ist die Standardeigenschaft des CaptureCollection-Objekts (in Visual Basic) oder Indexer (in C#).

Wenn ein Quantifizierer nicht für eine Erfassungsgruppe übernommen wird, enthält das CaptureCollection-Objekt ein einzelnes Capture-Objekt, das von geringem Interesse ist, da es Informationen zur gleichen Übereinstimmung wie das Group-Objekt enthält. Wenn ein Quantifizierer für eine Erfassungsgruppe übernommen wird, enthält das CaptureCollection-Objekt alle von der Erfassungsgruppe gemachten Erfassungen, und der letzte Member der Auflistung stellt die gleiche Erfassung wie das Group-Objekt dar.

Wenn Sie zum Beispiel das Muster ((a(b))c)+ eines regulären Ausdrucks verwenden (wobei der +-Quantifizierer mindestens eine Übereinstimmung angibt), um Übereinstimmungen von der Zeichenfolge "abcabcabc" zu erfassen, enthält das CaptureCollection-Objekt für jedes Group-Objekt drei Member.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "((a(b))c)+";
      string input = "abcabcabc";

      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Match: '{0}' at position {1}",
                           match.Value, match.Index);
         GroupCollection groups = match.Groups;
         for (int ctr = 0; ctr < groups.Count; ctr++) {
            Console.WriteLine("   Group {0}: '{1}' at position {2}",
                              ctr, groups[ctr].Value, groups[ctr].Index);
            CaptureCollection captures = groups[ctr].Captures;
            for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
               Console.WriteLine("      Capture {0}: '{1}' at position {2}",
                                 ctr2, captures[ctr2].Value, captures[ctr2].Index);
            }
         }
      }
   }
}
// The example displays the following output:
//       Match: 'abcabcabc' at position 0
//          Group 0: 'abcabcabc' at position 0
//             Capture 0: 'abcabcabc' at position 0
//          Group 1: 'abc' at position 6
//             Capture 0: 'abc' at position 0
//             Capture 1: 'abc' at position 3
//             Capture 2: 'abc' at position 6
//          Group 2: 'ab' at position 6
//             Capture 0: 'ab' at position 0
//             Capture 1: 'ab' at position 3
//             Capture 2: 'ab' at position 6
//          Group 3: 'b' at position 7
//             Capture 0: 'b' at position 1
//             Capture 1: 'b' at position 4
//             Capture 2: 'b' at position 7

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "((a(b))c)+"
        Dim input As STring = "abcabcabc"

        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Match: '{0}' at position {1}", _
                              match.Value, match.Index)
            Dim groups As GroupCollection = match.Groups
            For ctr As Integer = 0 To groups.Count - 1
                Console.WriteLine("   Group {0}: '{1}' at position {2}", _
                                  ctr, groups(ctr).Value, groups(ctr).Index)
                Dim captures As CaptureCollection = groups(ctr).Captures
                For ctr2 As Integer = 0 To captures.Count - 1
                    Console.WriteLine("      Capture {0}: '{1}' at position {2}", _
                                      ctr2, captures(ctr2).Value, captures(ctr2).Index)
                Next
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Match: 'abcabcabc' at position 0
'          Group 0: 'abcabcabc' at position 0
'             Capture 0: 'abcabcabc' at position 0
'          Group 1: 'abc' at position 6
'             Capture 0: 'abc' at position 0
'             Capture 1: 'abc' at position 3
'             Capture 2: 'abc' at position 6
'          Group 2: 'ab' at position 6
'             Capture 0: 'ab' at position 0
'             Capture 1: 'ab' at position 3
'             Capture 2: 'ab' at position 6
'          Group 3: 'b' at position 7
'             Capture 0: 'b' at position 1
'             Capture 1: 'b' at position 4
'             Capture 2: 'b' at position 7

Im folgenden Beispiel wird der reguläre Ausdruck (Abc)+ verwendet, um mindestens eine aufeinanderfolgende Ausführung der Zeichenfolge "Abc" in der Zeichenfolge "XYZAbcAbcAbcXYZAbcAb" zu suchen. Das Beispiel veranschaulicht die Verwendung der Group.Captures-Eigenschaft, um mehrere Gruppen erfasster Teilzeichenfolgen zurückzugeben.

int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;

// Look for groupings of "Abc".
var r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;

// Display the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());

// Loop through each group.
for (int i = 0; i < gc.Count; i++)
{
    cc = gc[i].Captures;
    counter = cc.Count;

    // Display the number of captures in this group.
    Console.WriteLine("Captures count = " + counter.ToString());

    // Loop through each capture in the group.
    for (int ii = 0; ii < counter; ii++)
    {
        // Display the capture and its position.
        Console.WriteLine(cc[ii] + "   Starts at character " +
             cc[ii].Index);
    }
}
// The example displays the following output:
//       Captured groups = 2
//       Captures count = 1
//       AbcAbcAbc   Starts at character 3
//       Captures count = 3
//       Abc   Starts at character 3
//       Abc   Starts at character 6
//       Abc   Starts at character 9

Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection

' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups

' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())

' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
    cc = gc(i).Captures
    counter = cc.Count

    ' Display the number of captures in this group.
    Console.WriteLine("Captures count = " & counter.ToString())

    ' Loop through each capture in the group.            
    For ii = 0 To counter - 1
        ' Display the capture and its position.
        Console.WriteLine(cc(ii).ToString() _
            & "   Starts at character " & cc(ii).Index.ToString())
    Next ii
Next i
' The example displays the following output:
'       Captured groups = 2
'       Captures count = 1
'       AbcAbcAbc   Starts at character 3
'       Captures count = 3
'       Abc   Starts at character 3
'       Abc   Starts at character 6
'       Abc   Starts at character 9

Die Capture-Klasse

Die Capture-Klasse enthält die Ergebnisse einer einzelnen Teilausdrucksuche. Die Capture.Value-Eigenschaft enthält den übereinstimmenden Text, und die Capture.Index-Eigenschaft gibt die nullbasierte Position in der Eingabezeichenfolge an, bei der die übereinstimmende Teilzeichenfolge beginnt.

Im folgenden Beispiel wird eine Eingabezeichenfolge hinsichtlich der Temperatur ausgewählter Orte analysiert. Ein Komma (",") wird verwendet, um einen Ort und seine Temperatur zu trennen. Ein Semikolon ("";) dient zum Trennen der Daten zu einzelnen Orten. Die gesamte Eingabezeichenfolge stellt eine einzelne Übereinstimmung dar. Im Muster ((\w+(\s\w+)*),(\d+);)+ eines regulären Ausdrucks, mit dem die Zeichenfolge analysiert wird, wird der Ortsname der zweiten Erfassungsgruppe und die Temperatur der vierten Erfassungsgruppe zugewiesen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;";
      string pattern = @"((\w+(\s\w+)*),(\d+);)+";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Current temperatures:");
         for (int ctr = 0; ctr < match.Groups[2].Captures.Count; ctr++)
            Console.WriteLine("{0,-20} {1,3}", match.Groups[2].Captures[ctr].Value,
                              match.Groups[4].Captures[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Current temperatures:
//       Miami                 78
//       Chicago               62
//       New York              67
//       San Francisco         59
//       Seattle               58

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;"
        Dim pattern As String = "((\w+(\s\w+)*),(\d+);)+"
        Dim match As Match = Regex.Match(input, pattern)
        If match.Success Then
            Console.WriteLine("Current temperatures:")
            For ctr As Integer = 0 To match.Groups(2).Captures.Count - 1
                Console.WriteLine("{0,-20} {1,3}", match.Groups(2).Captures(ctr).Value, _
                                  match.Groups(4).Captures(ctr).Value)
            Next
        End If
    End Sub
End Module
' The example displays the following output:
'       Current temperatures:
'       Miami                 78
'       Chicago               62
'       New York              67
'       San Francisco         59
'       Seattle               58

Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle definiert:

Muster Beschreibung
\w+ Übereinstimmung mit mindestens einem Wortzeichen.
(\s\w+)* Entsprechung für null oder mehr Vorkommen eines Leerstellenzeichens finden, auf das mindestens ein Wortzeichen folgt. Dieses Muster entspricht Ortsnamen, die aus mehreren Wörtern bestehen. Dies ist die dritte Erfassungsgruppe.
(\w+(\s\w+)*) Entsprechung für mindestens ein Wortzeichen finden, auf das null oder mehr Vorkommen eines Leerstellenzeichens folgen und mindestens ein Wortzeichen. Dies ist die zweite Erfassungsgruppe.
, Entsprechung für ein Komma finden.
(\d+) Entsprechung für mindestens eine Stelle finden. Dies ist die vierte Erfassungsgruppe.
; Entsprechung für ein Semikolon finden.
((\w+(\s\w+)*),(\d+);)+ Entsprechung für das Muster eines Worts finden, auf das alle weiteren Wörter folgen, auf die ein Komma, mindestens eine Ziffer und ein Semikolon folgen (mindestens einmal). Dies ist die erste Erfassungsgruppe.

Siehe auch