Teilen über

Reguläre .NET-Ausdrücke

Reguläre Ausdrücke bieten eine leistungsstarke, flexible und effiziente Methode zum Verarbeiten von Text. Die umfangreiche Musterabgleichsnotation regulärer Ausdrücke ermöglicht es Ihnen, große Textmengen schnell zu analysieren:

  • Suchen bestimmter Zeichenmuster.
  • Validieren von Text, um sicherzustellen, dass er mit einem vordefinierten Muster übereinstimmt (beispielsweise eine E-Mail-Adresse).
  • Extrahieren, bearbeiten, ersetzen oder löschen von Teilen der Textzeichenfolgen.
  • Fügen Sie einer Auflistung extrahierte Zeichenfolgen hinzu, um einen Bericht zu generieren.

Bei vielen Anwendungen, die mit Zeichenfolgen umgehen oder große Textblöcke analysieren, sind reguläre Ausdrücke ein unverzichtbares Tool.

Funktionsweise regulärer Ausdrücke

Das Herzstück der Textverarbeitung mit regulären Ausdrücken ist das Modul für reguläre Ausdrücke, das durch das System.Text.RegularExpressions.Regex Objekt in .NET dargestellt wird. Die Verarbeitung von Text mit regulären Ausdrücken erfordert mindestens, dass das Modul für reguläre Ausdrücke die folgenden beiden Informationselemente enthält:

  • Das Muster für reguläre Ausdrücke, das im Text identifiziert werden soll.

    In .NET werden reguläre Ausdrucksmuster durch eine spezielle Syntax oder Sprache definiert, die mit regulären Perl 5-Ausdrücken kompatibel ist, und fügt einige zusätzliche Features hinzu, z. B. rechts-nach-links-Abgleich. Weitere Informationen finden Sie unter "Sprache für reguläre Ausdrücke – Kurzübersicht".

  • Der Text, der nach dem Muster des regulären Ausdrucks analysiert werden soll.

Mit den Methoden der Regex Klasse können Sie die folgenden Vorgänge ausführen:

Eine Übersicht über das Objektmodell des regulären Ausdrucks finden Sie im Regulären Ausdrucksobjektmodell.

Weitere Informationen zur Sprache des regulären Ausdrucks finden Sie unter "Reguläre Ausdruckssprache " – Kurzübersicht oder Herunterladen und Drucken einer der folgenden Broschüren:

Beispiele für reguläre Ausdrücke

Die String Klasse enthält Zeichenfolgensuche- und Ersetzungsmethoden, die Sie verwenden können, wenn Sie Literalzeichenfolgen in einer größeren Zeichenfolge suchen möchten. Reguläre Ausdrücke sind am nützlichsten, wenn Sie eine von mehreren Teilzeichenfolgen in einer größeren Zeichenfolge suchen möchten oder wenn Sie Muster in einer Zeichenfolge identifizieren möchten, wie die folgenden Beispiele veranschaulichen.

Warnung

Wenn Sie System.Text.RegularExpressions verwenden, um nicht vertrauenswürdige Eingaben zu verarbeiten, übergeben Sie ein Timeout. Ein böswilliger Benutzer kann Eingaben für RegularExpressionsbereitstellen, was zu einem Denial-of-Service-Angriffführt. ASP.NET Core-Framework-APIs, die RegularExpressions verwenden, übergeben ein Timeout.

Tipp

Der System.Web.RegularExpressions Namespace enthält eine Reihe regulärer Ausdrucksobjekte, die vordefinierte reguläre Ausdrucksmuster zum Analysieren von Zeichenfolgen aus HTML-, XML- und ASP.NET-Dokumenten implementieren. Beispielsweise identifiziert die TagRegex Klasse Starttags in einer Zeichenfolge, und die CommentRegex Klasse identifiziert ASP.NET Kommentare in einer Zeichenfolge.

Beispiel 1: Ersetzen von Teilzeichenfolgen

Angenommen, eine Adressenliste enthält Namen, die manchmal einen Titel (Mr., Mrs., Miss oder Ms.) zusammen mit einem Vor- und Nachnamen enthalten. Angenommen, Sie möchten die Titel nicht einschließen, wenn Sie Umschlagbeschriftungen aus der Liste generieren. In diesem Fall können Sie einen regulären Ausdruck verwenden, um die Titel zu entfernen, wie das folgende Beispiel veranschaulicht:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(Mr\\.? |Mrs\\.? |Miss |Ms\\.? )";
      string[] names = { "Mr. Henry Hunt", "Ms. Sara Samuels",
                         "Abraham Adams", "Ms. Nicole Norris" };
      foreach (string name in names)
         Console.WriteLine(Regex.Replace(name, pattern, String.Empty));
   }
}
// The example displays the following output:
//    Henry Hunt
//    Sara Samuels
//    Abraham Adams
//    Nicole Norris

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(Mr\.? |Mrs\.? |Miss |Ms\.? )"
        Dim names() As String = {"Mr. Henry Hunt", "Ms. Sara Samuels", _
                                  "Abraham Adams", "Ms. Nicole Norris"}
        For Each name As String In names
            Console.WriteLine(Regex.Replace(name, pattern, String.Empty))
        Next
    End Sub
End Module
' The example displays the following output:
'    Henry Hunt
'    Sara Samuels
'    Abraham Adams
'    Nicole Norris

Das Muster für reguläre Ausdrücke (Mr\.? |Mrs\.? |Miss |Ms\.? ) entspricht jedem Vorkommen von „Mr “, „Mr. “, „Mrs “, „Mrs. “, „Miss “, „Ms “ oder „Ms. “. Der Aufruf der Regex.Replace Methode ersetzt die übereinstimmende Zeichenfolge durch String.Empty; mit anderen Worten, sie wird aus der ursprünglichen Zeichenfolge entfernt.

Beispiel 2: Identifizieren duplizierter Wörter

Versehentliches Duplizieren von Wörtern ist ein häufiger Fehler, den Autoren machen. Verwenden Sie einen regulären Ausdruck, um duplizierte Wörter zu identifizieren, wie das folgende Beispiel zeigt:

using System;
using System.Text.RegularExpressions;

public class Class1
{
   public static void Main()
   {
      string pattern = @"\b(\w+?)\s\1\b";
      string input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine($"{match.Value} (duplicates '{match.Groups[1].Value}') at position {match.Index}");
   }
}
// The example displays the following output:
//       This this (duplicates 'This') at position 0
//       a a (duplicates 'a') at position 66

Imports System.Text.RegularExpressions

Module modMain
    Public Sub Main()
        Dim pattern As String = "\b(\w+?)\s\1\b"
        Dim input As String = "This this is a nice day. What about this? This tastes good. I saw a a dog."
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
            Console.WriteLine("{0} (duplicates '{1}') at position {2}", _
                              match.Value, match.Groups(1).Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       This this (duplicates 'This') at position 0
'       a a (duplicates 'a') at position 66

Das Muster \b(\w+?)\s\1\b für reguläre Ausdrücke kann wie folgt interpretiert werden:

Muster Auslegung
\b An einer Wortgrenze beginnen.
(\w+?) Wählen Sie ein oder mehrere Wortzeichen aus, aber so wenige Zeichen wie möglich. Zusammen bilden sie eine Gruppe, die als \1 bezeichnet werden kann.
\s Entsprechung für ein Leerraumzeichen finden.
\1 Finden Sie die Teilzeichenfolge, die der Gruppe mit dem Namen \1 entspricht.
\b Übereinstimmung mit einer Wortgrenze.

Die Methode Regex.Matches wird mit den auf RegexOptions.IgnoreCase festgelegten Optionen für reguläre Ausdrücke aufgerufen. Beim Abgleichvorgang spielt die Groß- und Kleinschreibung daher keine Rolle, und die Teilzeichenfolge "This this" wird im Beispiel als Duplikat identifiziert.

Die Eingabezeichenfolge enthält die Teilzeichenfolge „this? Dies.“ Aufgrund des dazwischen liegenden Interpunktionszeichens wird es jedoch nicht als Duplizierung identifiziert.

Beispiel 3: Dynamisches Erstellen eines kultursensitiven regulären Ausdrucks

Das folgende Beispiel veranschaulicht die Leistungsfähigkeit regulärer Ausdrücke in Kombination mit der Flexibilität, die durch die Globalisierungsfunktionen von .NET geboten wird. Es verwendet das NumberFormatInfo Objekt, um das Format von Währungswerten in der aktuellen Kultur des Systems zu bestimmen. Anschließend werden diese Informationen verwendet, um einen regulären Ausdruck dynamisch zu konstruieren, der Währungswerte aus dem Text extrahiert. Für jede Übereinstimmung wird die Untergruppe extrahiert, die nur die numerische Zeichenfolge enthält. Diese wird in einen Decimal-Wert konvertiert, und dann wird ein laufender Gesamtbetrag berechnet.

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

public class Example
{
   public static void Main()
   {
      // Define text to be parsed.
      string input = "Office expenses on 2/13/2008:\n" +
                     "Paper (500 sheets)                      $3.95\n" +
                     "Pencils (box of 10)                     $1.00\n" +
                     "Pens (box of 10)                        $4.49\n" +
                     "Erasers                                 $2.19\n" +
                     "Ink jet printer                        $69.95\n\n" +
                     "Total Expenses                        $ 81.58\n";

      // Get current culture's NumberFormatInfo object.
      NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
      // Assign needed property values to variables.
      string currencySymbol = nfi.CurrencySymbol;
      bool symbolPrecedesIfPositive = nfi.CurrencyPositivePattern % 2 == 0;
      string groupSeparator = nfi.CurrencyGroupSeparator;
      string decimalSeparator = nfi.CurrencyDecimalSeparator;

      // Form regular expression pattern.
      string pattern = Regex.Escape( symbolPrecedesIfPositive ? currencySymbol : "") +
                       @"\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" +
                       Regex.Escape(decimalSeparator) + "[0-9]+)?)" +
                       (! symbolPrecedesIfPositive ? currencySymbol : "");
      Console.WriteLine( "The regular expression pattern is:");
      Console.WriteLine("   " + pattern);

      // Get text that matches regular expression pattern.
      MatchCollection matches = Regex.Matches(input, pattern,
                                              RegexOptions.IgnorePatternWhitespace);
      Console.WriteLine($"Found {matches.Count} matches.");

      // Get numeric string, convert it to a value, and add it to List object.
      List<decimal> expenses = new List<Decimal>();

      foreach (Match match in matches)
         expenses.Add(Decimal.Parse(match.Groups[1].Value));

      // Determine whether total is present and if present, whether it is correct.
      decimal total = 0;
      foreach (decimal value in expenses)
         total += value;

      if (total / 2 == expenses[expenses.Count - 1])
         Console.WriteLine($"The expenses total {expenses[expenses.Count - 1]:C2}.");
      else
         Console.WriteLine($"The expenses total {total:C2}.");
   }
}
// The example displays the following output:
//       The regular expression pattern is:
//          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
//       Found 6 matches.
//       The expenses total $81.58.

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

Public Module Example
    Public Sub Main()
        ' Define text to be parsed.
        Dim input As String = "Office expenses on 2/13/2008:" + vbCrLf + _
                              "Paper (500 sheets)                      $3.95" + vbCrLf + _
                              "Pencils (box of 10)                     $1.00" + vbCrLf + _
                              "Pens (box of 10)                        $4.49" + vbCrLf + _
                              "Erasers                                 $2.19" + vbCrLf + _
                              "Ink jet printer                        $69.95" + vbCrLf + vbCrLf + _
                              "Total Expenses                        $ 81.58" + vbCrLf
        ' Get current culture's NumberFormatInfo object.
        Dim nfi As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
        ' Assign needed property values to variables.
        Dim currencySymbol As String = nfi.CurrencySymbol
        Dim symbolPrecedesIfPositive As Boolean = CBool(nfi.CurrencyPositivePattern Mod 2 = 0)
        Dim groupSeparator As String = nfi.CurrencyGroupSeparator
        Dim decimalSeparator As String = nfi.CurrencyDecimalSeparator

        ' Form regular expression pattern.
        Dim pattern As String = Regex.Escape(CStr(IIf(symbolPrecedesIfPositive, currencySymbol, ""))) + _
                                "\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + _
                                Regex.Escape(decimalSeparator) + "[0-9]+)?)" + _
                                CStr(IIf(Not symbolPrecedesIfPositive, currencySymbol, ""))
        Console.WriteLine("The regular expression pattern is: ")
        Console.WriteLine("   " + pattern)

        ' Get text that matches regular expression pattern.
        Dim matches As MatchCollection = Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
        Console.WriteLine("Found {0} matches. ", matches.Count)

        ' Get numeric string, convert it to a value, and add it to List object.
        Dim expenses As New List(Of Decimal)

        For Each match As Match In matches
            expenses.Add(Decimal.Parse(match.Groups.Item(1).Value))
        Next

        ' Determine whether total is present and if present, whether it is correct.
        Dim total As Decimal
        For Each value As Decimal In expenses
            total += value
        Next

        If total / 2 = expenses(expenses.Count - 1) Then
            Console.WriteLine("The expenses total {0:C2}.", expenses(expenses.Count - 1))
        Else
            Console.WriteLine("The expenses total {0:C2}.", total)
        End If
    End Sub
End Module
' The example displays the following output:
'       The regular expression pattern is:
'          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
'       Found 6 matches.
'       The expenses total $81.58.

Auf einem Computer, dessen aktuelle Kultur Englisch ist - Vereinigte Staaten (en-US), erstellt das Beispiel dynamisch den regulären Ausdruck \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?). Dieses Muster für reguläre Ausdrücke kann wie folgt interpretiert werden:

Muster Auslegung
\$ Suchen Sie in der Eingabezeichenfolge nach einem einzelnen Vorkommen des Dollarsymbols ($). Die Musterzeichenfolge für reguläre Ausdrücke enthält einen Backslash, um anzugeben, dass das Dollarzeichen wörtlich interpretiert werden soll, anstatt als Anker eines regulären Ausdrucks. Das $-Symbol allein würde angeben, dass die Engine für reguläre Ausdrücke versuchen soll, mit der Suche nach Übereinstimmungen am Ende einer Zeichenfolge zu beginnen. Um sicherzustellen, dass das Währungssymbol der aktuellen Kultur nicht als reguläres Ausdruckssymbol fehlinterpretiert wird, wird im Beispiel die Regex.Escape-Methode aufgerufen, um das Zeichen mit Escapezeichen zu versehen.
\s* Suche nach 0 (null) oder mehr Vorkommen eines Leerstellenzeichens.
[-+]? Suche nach 0 (null) oder einem Vorkommen entweder eines positiven oder negativen Vorzeichens.
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) Die äußeren Klammern definieren diesen Ausdruck als Erfassungsgruppe oder Unterausdruck. Wenn ein Treffer gefunden wird, können Informationen über diesen Teil der übereinstimmenden Zeichenfolge aus dem zweiten Group Objekt des durch die GroupCollection Eigenschaft zurückgegebenen Match.Groups Objekts abgerufen werden. Das erste Element in der Auflistung stellt die gesamte Übereinstimmung dar.
[0-9]{0,3} Suchen Sie nach Null bis drei Vorkommen der Dezimalziffern 0 bis 9.
(,[0-9]{3})* Suchen Sie nach null oder mehr Vorkommen eines Gruppentrennzeichens gefolgt von drei Dezimalziffern.
\. Suche nach einem einzelnen Vorkommen des Dezimaltrennzeichens.
[0-9]+ Suchen Sie nach einer oder mehreren Dezimalziffern.
(\.[0-9]+)? Suchen Sie nach Null oder einem einzigen Vorkommen des Dezimaltrennzeichens, gefolgt von mindestens einer Dezimalziffer.

Wenn jede Unterpattern in der Eingabezeichenfolge gefunden wird, wird die Übereinstimmung erfolgreich ausgeführt, und ein Match Objekt, das Informationen zur Übereinstimmung enthält, wird dem MatchCollection Objekt hinzugefügt.

Titel BESCHREIBUNG
Sprache für reguläre Ausdrücke – Kurzübersicht Stellt Informationen zu den Zeichen, Operatoren und Konstrukten bereit, die Sie zum Definieren regulärer Ausdrücke verwenden können.
Das Objektmodell für reguläre Ausdrücke Stellt Informationen und Codebeispiele bereit, die veranschaulichen, wie die Klassen für reguläre Ausdrücke verwendet werden.
Einzelheiten zum Verhalten regulärer Ausdrücke Enthält Informationen zu den Funktionen und dem Verhalten regulärer .NET-Ausdrücke.
Verwenden regulärer Ausdrücke in Visual Studio

Referenz