Reguläre Ausdrücke von .NET

Der Einsatz regulärer Ausdrücke stellt eine leistungsstarke, flexible und effiziente Methode zur Verarbeitung von Text dar. Die umfangreiche Mustervergleichsnotation regulärer Ausdrücke ermöglicht es Ihnen, große Textmengen für folgende Zwecke schnell zu analysieren:

• Suchen nach bestimmten Zeichenmustern
• Überprüfen von Text, um sicherzustellen, dass er einem vordefinierten Muster (z. B. einer E-Mail-Adresse) entspricht
• Extrahieren, Bearbeiten, Ersetzen oder Löschen von Teilzeichenfolgen von Text
• Hinzufügen von extrahierten Zeichenfolgen zu einer Sammlung, um einen Bericht zu generieren

Für viele Anwendungen, die mit Zeichenfolgen arbeiten oder große Textblöcke analysieren, sind reguläre Ausdrücke ein unverzichtbares Tool.

Funktionsweise von regulären Ausdrücken

Das Kernstück der Textverarbeitung mit regulären Ausdrücken ist die Engine für reguläre Ausdrücke, die durch das System.Text.RegularExpressions.Regex-Objekt in .NET dargestellt wird. Für die Textverarbeitung mit regulären Ausdrücken ist mindestens erforderlich, dass die Engine für reguläre Ausdrücke mit den folgenden zwei Informationen bereitgestellt wird:

• Das Muster des regulären Ausdrucks, das im Text identifiziert werden soll.

  In .NET werden Muster für reguläre Ausdrücke durch eine spezielle Syntax oder Sprache definiert, die mit regulären Ausdrücken in Perl 5 kompatibel ist und einige zusätzliche Funktionen wie Mustervergleiche von rechts nach links bietet. Weitere Informationen finden Sie unter Sprachelemente 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 durchführen:

• Bestimmen, ob das Muster des regulären Ausdrucks im Eingabetext auftritt, indem die Regex.IsMatch-Methode aufgerufen wird. Ein Beispiel, in dem Text mithilfe der IsMatch-Methode überprüft wird, finden Sie unter Vorgehensweise: Überprüfen, ob Zeichenfolgen ein gültiges E-Mail-Format aufweisen.

• Abrufen eines oder aller Vorkommen des Texts, die dem Muster des regulären Ausdrucks entsprechen, indem die Regex.Match-Methode oder die Regex.Matches-Methode aufgerufen wird. Die erste Methode gibt ein System.Text.RegularExpressions.Match-Objekt zurück, das Informationen über den übereinstimmenden Text bereitstellt. Die zweite Methode gibt ein MatchCollection-Objekt zurück, das ein System.Text.RegularExpressions.Match-Objekt für jede im analysierten Text gefundene Übereinstimmung enthält.

• Ersetzen von Text, der dem Muster des regulären Ausdrucks entspricht, indem die Regex.Replace-Methode aufgerufen wird. Beispiele, in denen die Replace-Methode verwendet wird, um Datumsformate zu ändern und ungültige Zeichen aus einer Zeichenfolge zu entfernen, finden Sie unter Vorgehensweise: Entfernen von ungültigen Zeichen aus einer Zeichenfolge und Beispiel: Ändern von Datumsformaten.

Eine Übersicht über das Objektmodell für reguläre Ausdrücke finden Sie unter Das Objektmodell für reguläre Ausdrücke.

Weitere Informationen über die Sprache für reguläre Ausdrücke finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht. Sie können auch eine der folgenden Broschüren herunterladen und ausdrucken:

• Kurzübersicht im Word-Format (.docx)
• Kurzübersicht im PDF-Format (.pdf)

Beispiele für reguläre Ausdrücke

Die String-Klasse enthält von Such- und Ersetzungsmethoden für Zeichenfolgen, die Sie verwenden können, wenn Sie Literalzeichenfolgen in einer größeren Zeichenfolge suchen möchten. Reguläre Ausdrücke sind besonders hilfreich, wenn Sie eine von mehreren Teilzeichenfolgen in einer größeren Zeichenfolge suchen oder wenn Sie Muster in einer Zeichenfolge identifizieren möchten, wie in den folgenden Beispielen veranschaulicht wird.

Beispiel 1: Ersetzen von Teilzeichenfolgen

Angenommen, eine Mailingliste enthält neben dem Vor- und Nachnamen bei einigen Personen auch Angaben zur Anrede (Mr., Mrs., Miss oder Ms.). 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. “. Wenn Sie die Regex.Replace-Methode aufrufen, wird die entsprechende Zeichenfolge durch String.Empty ersetzt, d. h., die Zeichenfolge wird aus der ursprünglichen Zeichenfolge entfernt.

Beispiel 2: Identifizieren von doppelten Wörtern

Das versehentliche Erstellen doppelter Wörter ist ein Fehler, der häufig von Entwicklern gemacht wird. Identifizieren Sie mithilfe eines regulären Ausdrucks doppelte Wörter, wie im folgenden Beispiel gezeigt:

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("{0} (duplicates '{1}') at position {2}",
                           match.Value, match.Groups[1].Value, 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 des regulären Ausdrucks \b(\w+?)\s\1\b kann wie folgt interpretiert werden:

Die Regex.Matches-Methode wird aufgerufen, und die Optionen für den regulären Ausdruck sind auf RegexOptions.IgnoreCase festgelegt. 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? This" enthält. Aufgrund des dazwischenliegenden Satzzeichens wird diese jedoch nicht als Duplikat identifiziert.

Beispiel 3: Dynamisches Erstellen eines kulturabhängigen regulären Ausdrucks

Das folgende Beispiel veranschaulicht die Leistungsfähigkeit regulärer Ausdrücke in Kombination mit der Flexibilität der .NET-Globalisierungsfunktionen. Mit dem NumberFormatInfo-Objekt wird das Format von Währungswerten in der aktuellen Kultur des Systems bestimmt. Anschließend wird anhand dieser Informationen dynamisch ein regulärer Ausdruck erstellt, 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 {0} matches.", matches.Count);

      // 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 {0:C2}.", expenses[expenses.Count - 1]);
      else
         Console.WriteLine("The expenses total {0:C2}.", total);
   }
}
// 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.

Im Beispiel wird dynamisch der reguläre Ausdruck \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) auf einem Computer mit der aktuellen Kultur Englisch - USA (en-US) erstellt. Dieses Muster des regulären Ausdrucks kann wie folgt interpretiert werden:

Wenn jedes Teilmuster in der Eingabezeichenfolge gefunden wird, ist die Übereinstimmung erfolgreich, und dem Match-Objekt wird ein MatchCollection-Objekt hinzugefügt, das Informationen über die Übereinstimmung enthält.

Verwandte Artikel

Verweis

• System.Text.RegularExpressions
• System.Text.RegularExpressions.Regex
• Reguläre Ausdrücke – Kurzübersicht (Download im Word-Format)
• Reguläre Ausdrücke – Kurzübersicht (Download im PDF-Format)