System.Text.RegularExpressions.Regex-Klasse

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Die Regex Klasse stellt dar. Das reguläre Ausdrucksmodul von NET. Sie können diese Klasse verwenden, um:

• Analysieren Sie schnell große Textmengen, um bestimmte Zeichenmuster zu finden.
• Extrahieren, Bearbeiten, Ersetzen oder Löschen von Teilzeichenfolgen von Text
• Fügen Sie der Auflistung die extrahierten Zeichenfolgen hinzu, um einen Bericht zu generieren.

Um reguläre Ausdrücke zu verwenden, definieren Sie das Muster, das Sie in einem Textstream identifizieren möchten, indem Sie die in der Sprache regulärer Ausdrücke dokumentierte Syntax verwenden – Kurzübersicht. Als Nächstes können Sie ein Regex Objekt optional instanziieren. Schließlich rufen Sie eine Methode auf, die einen Vorgang ausführt, z. B. das Ersetzen von Text, der dem Muster für reguläre Ausdrücke entspricht, oder das Identifizieren einer Mustervergleichung.

Weitere Informationen zur Sprache des regulären Ausdrucks finden Sie in der Sprache für reguläre Ausdrücke – Kurzübersicht oder Herunterladen und Drucken einer dieser Broschüren:

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

Regex vs. String-Methoden

Die System.String Klasse enthält mehrere Such- und Vergleichsmethoden, mit denen Sie Musterabgleich mit Text ausführen können. Beispielsweise bestimmen die Methoden , und String.StartsWith String.EndsWithdie String.ContainsMethoden, ob eine Zeichenfolgeninstanz eine angegebene Teilzeichenfolge enthält; und die String.IndexOf, String.IndexOfAny, , String.LastIndexOfund String.LastIndexOfAny Methoden geben die Anfangsposition einer angegebenen Teilzeichenfolge in einer Zeichenfolge zurück. Verwenden Sie die Methoden der System.String Klasse, wenn Sie nach einer bestimmten Zeichenfolge suchen. Verwenden Sie die Regex Klasse, wenn Sie nach einem bestimmten Muster in einer Zeichenfolge suchen. Weitere Informationen und Beispiele finden Sie unter .NET Regular Expressions.

Statische Methoden im Vergleich zu Instanzen

Nachdem Sie ein Muster für reguläre Ausdrücke definiert haben, können Sie es dem Modul für reguläre Ausdrücke auf zwei Arten bereitstellen:

• Durch Instanziieren eines Regex Objekts, das den regulären Ausdruck darstellt. Hierzu übergeben Sie das Muster für reguläre Ausdrücke an einen Regex Konstruktor. Ein Regex Objekt ist unveränderlich. Wenn Sie ein Regex Objekt mit einem regulären Ausdruck instanziieren, kann der reguläre Ausdruck dieses Objekts nicht geändert werden.

• Durch Bereitstellen des regulären Ausdrucks und des Texts zum Suchen nach einer static (Shared in Visual Basic) Regex -Methode. Auf diese Weise können Sie einen regulären Ausdruck verwenden, ohne ein Regex Objekt explizit zu erstellen.

Alle Regex Musteridentifikationsmethoden enthalten sowohl statische als auch Instanzüberladungen.

Das Modul für reguläre Ausdrücke muss ein bestimmtes Muster kompilieren, bevor das Muster verwendet werden kann. Da Regex Objekte unveränderlich sind, handelt es sich um eine einmalige Prozedur, die auftritt, wenn ein Regex Klassenkonstruktor oder eine statische Methode aufgerufen wird. Um zu vermeiden, dass ein einzelner regulärer Ausdruck wiederholt kompiliert werden muss, speichert das Reguläre Ausdrucksmodul die kompilierten regulären Ausdrücke zwischen, die in statischen Methodenaufrufen verwendet werden. Daher bieten Musterabgleichsmethoden für reguläre Ausdrücke eine vergleichbare Leistung für statische und Instanzmethoden. Das Zwischenspeichern kann jedoch die Leistung in den folgenden beiden Fällen beeinträchtigen:

• Wenn Sie statische Methodenaufrufe mit einer großen Anzahl regulärer Ausdrücke verwenden. Standardmäßig speichert das Modul für reguläre Ausdrücke die 15 zuletzt verwendeten statischen regulären Ausdrücke zwischen. Wenn Ihre Anwendung mehr als 15 statische reguläre Ausdrücke verwendet, müssen einige reguläre Ausdrücke neu kompiliert werden. Um diese Neukompilierung zu verhindern, können Sie die Regex.CacheSize Eigenschaft erhöhen.

• Wenn Sie neue Regex Objekte mit regulären Ausdrücken instanziieren, die zuvor kompiliert wurden. Der folgende Code definiert beispielsweise einen regulären Ausdruck, um duplizierte Wörter in einem Textstream zu finden. Obwohl im Beispiel ein einzelner regulärer Ausdruck verwendet wird, instanziiert es ein neues Regex Objekt, um jede Textzeile zu verarbeiten. Dies führt zur Neukompilierung des regulären Ausdrucks mit jeder Iteration der Schleife.

  StreamReader sr = new StreamReader(filename);
  string input;
  string pattern = @"\b(\w+)\s\1\b";
  while (sr.Peek() >= 0)
  {
     input = sr.ReadLine();
     Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
     MatchCollection matches = rgx.Matches(input);
     if (matches.Count > 0)
     {
        Console.WriteLine("{0} ({1} matches):", input, matches.Count);
        foreach (Match match in matches)
           Console.WriteLine("   " + match.Value);
     }
  }
  sr.Close();
  

  Dim sr As New StreamReader(filename)
  Dim input As String
  Dim pattern As String = "\b(\w+)\s\1\b"
  Do While sr.Peek() >= 0
     input = sr.ReadLine()
     Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
     Dim matches As MatchCollection = rgx.Matches(input)
     If matches.Count > 0 Then
        Console.WriteLine("{0} ({1} matches):", input, matches.Count)
        For Each match As Match In matches
           Console.WriteLine("   " + match.Value)
        Next   
     End If
  Loop
  sr.Close()
  

  Um eine Neukompilierung zu verhindern, sollten Sie ein einzelnes Regex Objekt instanziieren, auf das für den gesamten Code zugegriffen werden kann, der dies erfordert, wie im folgenden neu geschriebenen Beispiel gezeigt.

  StreamReader sr = new StreamReader(filename);
  string input;
  string pattern = @"\b(\w+)\s\1\b";
  Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
  
  while (sr.Peek() >= 0)
  {
     input = sr.ReadLine();
     MatchCollection matches = rgx.Matches(input);
     if (matches.Count > 0)
     {
        Console.WriteLine("{0} ({1} matches):", input, matches.Count);
        foreach (Match match in matches)
           Console.WriteLine("   " + match.Value);
     }
  }
  sr.Close();
  

  Dim sr As New StreamReader(filename)
  Dim input As String
  Dim pattern As String = "\b(\w+)\s\1\b"
  Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
  Do While sr.Peek() >= 0
     input = sr.ReadLine()
     Dim matches As MatchCollection = rgx.Matches(input)
     If matches.Count > 0 Then
        Console.WriteLine("{0} ({1} matches):", input, matches.Count)
        For Each match As Match In matches
           Console.WriteLine("   " + match.Value)
        Next   
     End If
  Loop
  sr.Close()
  

Ausführen regulärer Ausdrücke

Unabhängig davon, ob Sie ein Regex Objekt instanziieren und dessen Methoden aufrufen oder statische Methoden aufrufen möchten, bietet die Regex Klasse die folgenden Musterabgleichsfunktionen:

• Überprüfung einer Übereinstimmung. Sie rufen die IsMatch Methode auf, um zu bestimmen, ob eine Übereinstimmung vorhanden ist.

• Abrufen einer einzelnen Übereinstimmung. Sie rufen die Match Methode auf, um ein Match Objekt abzurufen, das die erste Übereinstimmung in einer Zeichenfolge oder in Einem Teil einer Zeichenfolge darstellt. Nachfolgende Übereinstimmungen können durch Aufrufen der Match.NextMatch Methode abgerufen werden.

• Abrufen aller Übereinstimmungen. Sie rufen die Matches Methode auf, um ein System.Text.RegularExpressions.MatchCollection Objekt abzurufen, das alle Übereinstimmungen in einer Zeichenfolge oder in Einem Teil einer Zeichenfolge darstellt.

• Ersetzen von übereinstimmendem Text. Sie rufen die Replace Methode auf, um übereinstimmenden Text zu ersetzen. Der Ersetzungstext kann auch durch einen regulären Ausdruck definiert werden. Darüber hinaus enthalten einige Methoden Replace einen MatchEvaluator Parameter, mit dem Sie den Ersetzungstext programmgesteuert definieren können.

• Erstellen eines Zeichenfolgenarrays, das aus Teilen einer Eingabezeichenfolge gebildet wird. Sie rufen die Split Methode auf, um eine Eingabezeichenfolge an Positionen aufzuteilen, die vom regulären Ausdruck definiert werden.

Zusätzlich zu den Musterabgleichsmethoden umfasst die Regex Klasse mehrere spezielle Methoden:

• Die Escape Methode escapet alle Zeichen, die als Operatoren für reguläre Ausdrücke in einem regulären Ausdruck oder einer Eingabezeichenfolge interpretiert werden können.
• Die Unescape Methode entfernt diese Escapezeichen.
• Die CompileToAssembly Methode erstellt eine Assembly, die vordefinierte reguläre Ausdrücke enthält. .NET enthält Beispiele für diese speziellen Assemblys im System.Web.RegularExpressions Namespace.

Definieren eines Timeoutwerts

.NET unterstützt eine sprache mit regulären Ausdrücken mit vollem Funktionsumfang, die erhebliche Leistungsfähigkeit und Flexibilität beim Abgleich von Mustern bietet. Die Leistungsfähigkeit und Flexibilität sind jedoch kostenaufwendig: das Risiko einer schlechten Leistung. Reguläre Ausdrücke, die schlecht ausgeführt werden, sind überraschend einfach zu erstellen. In einigen Fällen können reguläre Ausdrucksvorgänge, die auf übermäßigem Rückverfolgungsvorgang basieren, scheinbar nicht mehr reagieren, wenn sie Text verarbeiten, der fast mit dem Muster für reguläre Ausdrücke übereinstimmt. Weitere Informationen zum .NET Regular Expression-Modul finden Sie unter Details zum Verhalten regulärer Ausdrücke. Weitere Informationen zu übermäßigem Backtracking finden Sie unter "Backtracking".

Ab .NET Framework 4.5 können Sie ein Timeoutintervall für Übereinstimmungen mit regulären Ausdrücken definieren, um übermäßige Rückverfolgung zu begrenzen. Je nach Regulärem Ausdrucksmuster und Eingabetext überschreitet die Ausführungszeit möglicherweise das angegebene Timeoutintervall, sie verbringt jedoch nicht mehr Zeitrückverfolgung als das angegebene Timeoutintervall. Wenn das Modul für reguläre Ausdrücke auszeit, löst es eine Ausnahme aus RegexMatchTimeoutException . In den meisten Fällen verhindert dies, dass das Modul für reguläre Ausdrücke Die Verarbeitungsleistung verhindert, indem versucht wird, Text abzugleichen, der fast dem Muster des regulären Ausdrucks entspricht. Es kann jedoch auch darauf hinweisen, dass das Timeoutintervall zu niedrig festgelegt wurde oder dass die aktuelle Maschinenlast eine allgemeine Leistungsbeeinträchtigung verursacht hat.

Die Behandlung der Ausnahme hängt von der Ursache der Ausnahme ab. Wenn die Ausnahme auftritt, weil das Timeoutintervall zu niedrig oder aufgrund einer übermäßigen Computerlast festgelegt ist, können Sie das Timeoutintervall erhöhen und den Abgleich wiederholen. Wenn die Ausnahme auftritt, da der reguläre Ausdruck auf übermäßiger Rückverfolgung beruht, können Sie davon ausgehen, dass keine Übereinstimmung vorhanden ist, und optional können Sie Informationen protokollieren, die Ihnen beim Ändern des Musters für reguläre Ausdrücke helfen.

Sie können ein Timeoutintervall festlegen, indem Sie den Regex(String, RegexOptions, TimeSpan) Konstruktor aufrufen, wenn Sie ein reguläres Ausdrucksobjekt instanziieren. Bei statischen Methoden können Sie ein Timeoutintervall festlegen, indem Sie eine Überladung einer Abgleichsmethode aufrufen, die über einen matchTimeout Parameter verfügt. Wenn Sie keinen Timeoutwert explizit festlegen, wird der Standardtimeoutwert wie folgt bestimmt:

• Mithilfe des anwendungsweiten Timeoutwerts, sofern vorhanden. Legen Sie den anwendungsweiten Timeoutwert fest, indem Sie die AppDomain.SetData Methode aufrufen, um der Eigenschaft die Zeichenfolgendarstellung eines TimeSpan Werts zuzuweisen REGEX_DEFAULT_MATCH_TIMEOUT .
• Mithilfe des Werts InfiniteMatchTimeout, wenn kein anwendungsweiter Timeoutwert festgelegt wurde.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um nach wiederholten Vorkommen von Wörtern in einer Zeichenfolge zu suchen. Der reguläre Ausdruck \b(?<word>\w+)\s+(\k<word>)\b kann wie in der folgenden Tabelle dargestellt interpretiert werden.

using System;
using System.Text.RegularExpressions;

public class Test
{
    public static void Main ()
    {
        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}",
                          matches.Count,
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",
                              groups["word"].Value,
                              groups[0].Index,
                              groups[1].Index);
        }
    }
}

// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 49 and 53

Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 49 and 53

Im nächsten Beispiel wird die Verwendung eines regulären Ausdrucks veranschaulicht, um zu überprüfen, ob eine Zeichenfolge entweder einen Währungswert darstellt oder das richtige Format aufweist, um einen Währungswert darzustellen. In diesem Fall wird der reguläre Ausdruck dynamisch aus der NumberFormatInfo.CurrencyDecimalSeparatorNumberFormatInfo.NegativeSignCurrencyDecimalDigitsNumberFormatInfo.CurrencySymbolNumberFormatInfo.PositiveSign en-US-Kultur und den Eigenschaften der en-US-Kultur erstellt. Der resultierende reguläre Ausdruck ist ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Dieser reguläre Ausdruck kann wie in der folgenden Tabelle dargestellt interpretiert werden.

In diesem Fall geht der reguläre Ausdruck davon aus, dass eine gültige Währungszeichenfolge keine Gruppentrennzeichen enthält und dass sie entweder keine Bruchstellen oder die Anzahl der Bruchstellen enthält, die durch die Eigenschaft der angegebenen Kultur CurrencyDecimalDigits definiert werden.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        // Get the en-US NumberFormatInfo object to build the regular 
        // expression pattern dynamically.
        NumberFormatInfo nfi = CultureInfo.GetCultureInfo("en-US").NumberFormat;

        // Define the regular expression pattern.
        string pattern;
        pattern = @"^\s*[";
        // Get the positive and negative sign symbols.
        pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
        // Get the currency symbol.
        pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
        // Add integral digits to the pattern.
        pattern += @"(\d*";
        // Add the decimal separator.
        pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
        // Add the fractional digits.
        pattern += @"(\d{";
        // Determine the number of fractional digits in currency values.
        pattern += nfi.CurrencyDecimalDigits.ToString() + "})?){1}$";

        Console.WriteLine($"Pattern is {pattern}\n");

        Regex rgx = new Regex(pattern);

        // Define some test strings.
        string[] tests = { "-42", "19.99", "0.001", "100 USD",
                         ".34", "0.34", "1,052.21", "$10.62",
                         "+1.43", "-$0.23" };

        // Check each test string against the regular expression.
        foreach (string test in tests)
        {
            if (rgx.IsMatch(test))
                Console.WriteLine($"{test} is a currency value.");
            else
                Console.WriteLine($"{test} is not a currency value.");
        }
    }
}
// The example displays the following output:
//       Pattern is ^\s*[\+-]?\s?\$?\s?(\d*\.?(\d{2})?){1}$
//
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.

Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = CultureInfo.GetCultureInfo("en-US").NumberFormat

      ' Define the regular expression pattern.
      Dim pattern As String 
      pattern = "^\s*["
      ' Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + "]?\s?"
      ' Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + "?\s?"
      ' Add integral digits to the pattern.
      pattern += "(\d*"
      ' Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?"
      ' Add the fractional digits.
      pattern += "(\d{"
      ' Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "})?){1}$"
      
      Console.WriteLine("Pattern is {0}", pattern)
      Console.WriteLine()
      
      Dim rgx As New Regex(pattern)

      ' Define some test strings.
      Dim tests() As String = {"-42", "19.99", "0.001", "100 USD", _
                               ".34", "0.34", "1,052.21", "$10.62", _
                               "+1.43", "-$0.23" }

      ' Check each test string against the regular expression.
      For Each test As String In tests
         If rgx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       Pattern is ^\s*[\+-]?\s?\$?\s?(\d*\.?(\d{2})?){1}$
'
'       -42 is a currency value.
'       19.99 is a currency value.
'       0.001 is not a currency value.
'       100 USD is not a currency value.
'       .34 is a currency value.
'       0.34 is a currency value.
'       1,052.21 is not a currency value.
'       $10.62 is a currency value.
'       +1.43 is a currency value.
'       -$0.23 is a currency value.

Da der reguläre Ausdruck in diesem Beispiel dynamisch erstellt wird, wissen Sie zur Entwurfszeit nicht, ob das Währungssymbol, das Dezimalzeichen oder das positive und negative Zeichen der angegebenen Kultur (in diesem Beispiel en-US) vom Regulären Ausdrucksmodul als Operatoren für reguläre Ausdrücke falsch interpretiert werden. Um fehlzuinterpretieren, übergibt das Beispiel jede dynamisch generierte Zeichenfolge an die Escape Methode.