Dieser Artikel wurde manuell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original
Informationen
Das angeforderte Thema wird unten angezeigt. Es ist jedoch nicht in dieser Bibliothek vorhanden.

Reguläre Ausdrücke von .NET Framework

Der Einsatz regulärer Ausdrücke stellt eine leistungsstarke, flexible und effiziente Methode zur Verarbeitung von Text dar. Durch die umfangreiche Notation regulärer Ausdrücke für den Mustervergleich können folgende Aufgaben ausgeführt werden: schnelle Auswertung großer Textmengen zur Suche nach speziellen Zeichenmustern; Validieren von Text, um sicherzustellen, dass er einem vordefinierten Muster entspricht (z. B. eine E-Mail-Adresse); Extrahieren, Bearbeiten, Ersetzen oder Löschen von Textzeichenfolgen; Hinzufügen der extrahierten Zeichenfolgen zu einer Auflistung, um einen Bericht zu erstellen. Für viele Anwendungen, die mit Zeichenfolgen arbeiten oder große Textblöcke analysieren, sind reguläre Ausdrücke ein unverzichtbares Tool.

Das Kernstü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 Framework dargestellt wird. Für die Textverarbeitung mit regulären Ausdrücken ist mindestens erforderlich, dass das Modul 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 Framework werden Muster für reguläre Ausdrücke von einer speziellen 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:

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)
      

Die String-Klasse enthält eine Reihe 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.

hs600312.collapse_all(de-de,VS.110).gifBeispiel 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.). Wenn Sie Adressaufkleber aus der Liste generieren, die Anrede dabei jedoch unberücksichtigt lassen möchten, können Sie diese mithilfe eines regulären Ausdrucks entfernen, wie im folgenden Beispiel veranschaulicht wird.


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


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.

hs600312.collapse_all(de-de,VS.110).gifBeispiel 2: Identifizieren von doppelten Wörtern

Das versehentliche Erstellen doppelter Wörter ist ein Fehler, der häufig von Entwicklern gemacht wird. Mithilfe eines regulären Ausdrucks können Sie doppelte Wörter identifizieren, wie im folgenden Beispiel veranschaulicht wird.


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


Das Muster des regulären Ausdrucks \b(\w+?)\s\1\b kann wie folgt interpretiert werden:

\b

An einer Wortgrenze beginnen.

(\w+?)

Entspricht einem oder mehreren Wortzeichen, aber so wenigen Zeichen wie möglich. Zusammen bilden diese eine Gruppe, auf die mit \1 verwiesen werden kann.

\s

Entsprechung für ein Leerraumzeichen finden.

\1

Entsprechung für die Teilzeichenfolge finden, die gleich der Gruppe \1 ist.

\b

Übereinstimmung mit einer Wortgrenze.

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.

Beachten Sie, dass die Eingabezeichenfolge die Teilzeichenfolge "this? This" enthält. Aufgrund des dazwischenliegenden Satzzeichens wird diese jedoch nicht als Duplikat identifiziert.

hs600312.collapse_all(de-de,VS.110).gifBeispiel 3: Dynamisches Erstellen eines kulturabhängigen regulären Ausdrucks

Das folgende Beispiel veranschaulicht die Leistungsfähigkeit regulärer Ausdrücke in Kombination mit der durch die .NET Framework-Globalisierungsfunktionen gebotenen Flexibilität. 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.


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:

\$

Suche nach einem einzelnen Vorkommen des Dollarsymbols ($) in der Eingabezeichenfolge. Die Musterzeichenfolge des regulären Ausdrucks schließt einen umgekehrten Schrägstrich ein, der angibt, dass das Dollarsymbol nicht als Anchor des regulären Ausdrucks, sondern wörtlich interpretiert werden soll. (Das $-Symbol allein würde angeben, dass das Modul 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 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 eines negativen Vorzeichens.

([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)

Die äußeren Klammern um diesen Ausdruck definieren ihn als Erfassungsgruppe oder Teilausdruck. Wenn eine Übereinstimmung gefunden wird, können Informationen über diesen Teil der übereinstimmenden Zeichenfolge aus dem zweiten Group-Objekt in dem GroupCollection-Objekt abgerufen werden, das von der Match.Groups-Eigenschaft zurückgegeben wird. (Das erste Element in der Auflistung stellt die gesamte Übereinstimmung dar.)

[0-9]{0,3}

Suche nach 0 (null) bis drei Vorkommen der Dezimalstellen 0 bis 9.

(,[0-9]{3})*

Suche nach 0 (null) oder mehr Vorkommen eines Gruppentrennzeichens gefolgt von drei Dezimalstellen.

\.

Suche nach einem einzelnen Vorkommen des Dezimaltrennzeichens.

[0-9]+

Suche nach einer oder mehr Dezimalstellen.

(\.[0-9]+)?

Suche nach 0 (null) oder einem Vorkommen des Dezimaltrennzeichens, auf das mindestens eine Dezimalstelle folgt.

Wenn jedes dieser 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.

Titel

Beschreibung

Sprachelemente für reguläre Ausdrücke – Kurzübersicht

Informationen zu Zeichensatz, Operatoren und Konstrukten, mit denen Sie reguläre Ausdrücke definieren können.

Das Objektmodell für reguläre Ausdrücke

Ausführliche Informationen und Codebeispiele, die die Verwendung von Klassen für reguläre Ausdrücke veranschaulichen.

Einzelheiten zum Verhalten regulärer Ausdrücke

Ausführliche Informationen zu den Funktionen und dem Verhalten von regulären Ausdrücken in .NET Framework.

Beispiele für reguläre Ausdrücke

Codebeispiele, die typische Anwendungen regulärer Ausdrücke veranschaulichen.

[ N:System.Text.RegularExpressions ]
System.Text.RegularExpressions.Regex

Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.
Anzeigen:
© 2015 Microsoft