Regex Klasse

Definition

Stellt einen unveränderlichen regulären Ausdruck dar.

public ref class Regex
public ref class Regex : System::Runtime::Serialization::ISerializable
public class Regex
public class Regex : System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
type Regex = class
    interface ISerializable
[<System.Serializable>]
type Regex = class
    interface ISerializable
Public Class Regex
Public Class Regex
Implements ISerializable
Vererbung
Regex
Abgeleitet
Attribute
Implementiert

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.

Muster BESCHREIBUNG
\b Starten Sie die Übereinstimmung an einer Wortgrenze.
(?<word>\w+) Passen Sie mindestens ein Wortzeichen bis zu einer Wortgrenze ab. Nennen Sie diese erfasste Gruppe word.
\s+ Übereinstimmung mit mindestens einem Leerzeichen finden.
(\k<word>) Entspricht der erfassten Gruppe mit dem Namen word.
\b Übereinstimmung mit einer Wortgrenze.
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(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.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}
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

Das folgende Beispiel veranschaulicht die Verwendung eines regulären Ausdrucks, um zu überprüfen, ob eine Zeichenfolge entweder einen Währungswert darstellt oder das richtige Format hat, um einen Währungswert darzustellen. In diesem Fall wird der reguläre Ausdruck dynamisch aus den NumberFormatInfo.CurrencyDecimalSeparatorEigenschaften , , CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbolNumberFormatInfo.NegativeSignund NumberFormatInfo.PositiveSign für die 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.

Muster BESCHREIBUNG
^ Beginnen Sie am Anfang der Zeichenfolge.
\s* Sucht nach 0 (null) oder mehr Leerzeichen.
[\+-]? Übereinstimmung mit null oder einem Vorkommen des positiven oder negativen Zeichens.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.
\$? Entspricht null oder einem Vorkommen des Dollarzeichens.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.
\d* 0 (null) oder mehr Dezimalstellen sollen übereinstimmen.
\.? Entspricht dem Null- oder einem Dezimalpunktsymbol.
(\d{2})? Erfassungsgruppe 1: Übereinstimmung mit zwei Dezimalstellen null oder einmal.
(\d*\.?(\d{2})?){1} Passen Sie mindestens einmal das Muster von Integral- und Bruchstellen an, die durch ein Dezimalzeichen getrennt sind.
$ Stimmen Sie mit dem Ende der Zeichenfolge überein.

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 von Bruchstellen aufweist, 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 positive und negative Zeichen der angegebenen Kultur (in diesem Beispiel en-US) von der Engine für reguläre Ausdrücke als Operatoren für reguläre Ausdrücke falsch interpretiert werden könnten. Um Fehlinterpretationen zu vermeiden, übergibt das Beispiel jede dynamisch generierte Zeichenfolge an die Escape -Methode.

Hinweise

Die Regex -Klasse stellt die Engine für reguläre Ausdrücke des .NET Framework dar. Es kann verwendet werden, um große Mengen von Text schnell zu analysieren, um bestimmte Zeichenmuster zu finden. um Textunterzeichenfolgen zu extrahieren, zu bearbeiten, zu ersetzen oder zu löschen; und, um die extrahierten Zeichenfolgen einer Auflistung hinzuzufügen, um einen Bericht zu generieren.

Hinweis

Wenn Sie in erster Linie eine Zeichenfolge überprüfen möchten, indem Sie feststellen, ob sie einem bestimmten Muster entspricht, können Sie die System.Configuration.RegexStringValidator -Klasse verwenden.

Um reguläre Ausdrücke zu verwenden, definieren Sie das Muster, das Sie in einem Textstream identifizieren möchten, indem Sie die syntax verwenden, die in Regular Expression Language – Quick Reference dokumentiert ist. Als Nächstes können Sie optional ein Regex Objekt 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 Musterüberstimmung.

Hinweis

Einige gängige Muster regulärer Ausdrücke finden Sie unter Beispiele für reguläre Ausdrücke. Es gibt auch eine Reihe von Onlinebibliotheken mit regulären Ausdrucksmustern, z. B. die bibliothek in Regular-Expressions.info.

Weitere Informationen zur Verwendung der Regex -Klasse finden Sie in den folgenden Abschnitten in diesem Thema:

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)

Regex- und Zeichenfolgenmethoden

Die System.String -Klasse enthält mehrere Such- und Vergleichsmethoden, die Sie zum Durchführen der Musterabgleiche mit Text verwenden können. Beispielsweise bestimmen die String.ContainsMethoden , String.EndsWithund String.StartsWith , ob eine Zeichenfolgeninstanz eine angegebene Teilzeichenfolge enthält. Und die String.IndexOfMethoden , String.IndexOfAny, String.LastIndexOfund String.LastIndexOfAny geben die Startposition 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 Reguläre .NET-Ausdrücke.

Zurück zu Anmerkungen

Statische Methoden im Vergleich zu Instanzmethoden

Nachdem Sie ein Muster für reguläre Ausdrücke definiert haben, können Sie es der Engine 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.

  • Indem Sie sowohl den regulären Ausdruck als auch den Zu suchenden Text für eine static (Shared in Visual Basic) Regex -Methode angeben. Dadurch können Sie einen regulären Ausdruck verwenden, ohne explizit ein Regex Objekt zu erstellen.

Alle Regex Methoden zur Musteridentifizierung enthalten sowohl statische als auch Instanzüberladungen.

Die Engine für reguläre Ausdrücke muss ein bestimmtes Muster kompilieren, bevor das Muster verwendet werden kann. Da Regex Objekte unveränderlich sind, ist dies eine einmalige Prozedur, die auftritt, wenn ein Regex Klassenkonstruktor oder eine statische Methode aufgerufen wird. Um die Notwendigkeit zu vermeiden, einen einzelnen regulären Ausdruck wiederholt zu kompilieren, speichert die Engine für reguläre Ausdrücke die kompilierten regulären Ausdrücke zwischen, die in statischen Methodenaufrufen verwendet werden. Daher bieten reguläre Ausdrucksmusterabgleichsmethoden eine vergleichbare Leistung für statische Methoden und Instanzmethoden.

Wichtig

In den .NET Framework Versionen 1.0 und 1.1 wurden alle kompilierten regulären Ausdrücke zwischengespeichert, unabhängig davon, ob sie in Instanzaufrufen oder statischen Methodenaufrufen verwendet wurden. Ab dem .NET Framework 2.0 werden nur reguläre Ausdrücke zwischengespeichert, die in statischen Methodenaufrufen verwendet werden.

Die Zwischenspeicherung kann sich jedoch in den folgenden beiden Fällen negativ auf die Leistung auswirken:

  • Wenn Sie statische Methodenaufrufe mit einer großen Anzahl regulärer Ausdrücke verwenden. Standardmäßig speichert die Engine 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 nach duplizierten Wörtern in einem Textstream zu suchen. 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 umgeschriebenen 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()
    

Zurück zu Anmerkungen

Ausführen von Vorgängen mit regulären Ausdrücken

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

  • Ü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 einem Teil einer Zeichenfolge darstellt.

  • Ersetzung von übereinstimmendem Text. Sie rufen die Replace -Methode auf, um übereinstimmenden Text zu ersetzen. Der Ersatztext kann auch durch einen regulären Ausdruck definiert werden. Darüber hinaus enthalten einige der Methoden einen MatchEvaluator Parameter, mit dem Replace 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 durch den regulären Ausdruck definiert werden.

Zusätzlich zu ihren Musterabgleichsmethoden enthält 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. Die .NET Framework enthält Beispiele für diese Speziellen Assemblys im System.Web.RegularExpressions Namespace.

Zurück zu Anmerkungen

Definieren eines Time-Out-Werts

.NET unterstützt eine voll funktionsfähige Sprache für reguläre Ausdrücke, die eine erhebliche Leistung und Flexibilität beim Musterabgleich bietet. Die Leistung und Flexibilität haben jedoch ihren Preis: das Risiko schlechter Leistung. Reguläre Ausdrücke, die schlecht funktionieren, lassen sich erstaunlich einfach erstellen. In einigen Fällen können reguläre Ausdrucksvorgänge, die auf übermäßigem Rückverfolgungsvorgang basieren, den Anschein haben, nicht mehr zu reagieren, wenn sie Text verarbeiten, der fast dem muster des regulären Ausdrucks entspricht. Weitere Informationen zur .NET-Engine für reguläre Ausdrücke finden Sie unter Details zum Verhalten regulärer Ausdrücke. Weitere Informationen zu übermäßigem Backtracking finden Sie unter Backtracking.

Ab dem .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. Abhängig vom Regulären Ausdrucksmuster und dem Eingabetext kann die Ausführungszeit das angegebene Timeoutintervall überschreiten, aber es wird nicht mehr Zeit für die Rückverfolgung als das angegebene Timeoutintervall ausgegeben. Wenn für die Engine für reguläre Ausdrücke ein Zeitüberschreitungsvorgang auftritt, wird eine RegexMatchTimeoutException Ausnahme ausgelöst. In den meisten Fällen verhindert dies, dass die Engine für reguläre Ausdrücke die Verarbeitungsleistung durch den Versuch, Text abzugleichen, der fast dem Muster für reguläre Ausdrücke entspricht. Es kann jedoch auch darauf hindeuten, dass das Timeoutintervall zu niedrig festgelegt wurde oder dass die aktuelle Computerlast eine allgemeine Leistungsbeeinträchtigung verursacht hat.

Wie Sie die Ausnahme behandeln, hängt von der Ursache der Ausnahme ab. Wenn die Ausnahme auftritt, weil das Timeoutintervall zu niedrig oder aufgrund übermäßiger Computerlast festgelegt ist, können Sie das Timeoutintervall erhöhen und den Abgleichsvorgang wiederholen. Wenn die Ausnahme auftritt, weil der reguläre Ausdruck auf übermäßiger Rückverfolgung angewiesen ist, 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 übereinstimmenden Methode aufrufen, die über einen matchTimeout Parameter verfügt. Wenn Sie einen Timeoutwert nicht explizit festlegen, wird der Standardtimeoutwert wie folgt bestimmt:

  • Verwenden Sie den anwendungsweiten Timeoutwert, sofern vorhanden. Dies kann ein beliebiger Timeoutwert sein, der für die Anwendungsdomäne gilt, in der das Regex Objekt instanziiert oder der statische Methodenaufruf erfolgt. Sie können den anwendungsweiten Timeoutwert festlegen, indem Sie die AppDomain.SetData -Methode aufrufen, um der Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT" die Zeichenfolgendarstellung eines TimeSpan Werts zuzuweisen.

  • Mithilfe des -Werts InfiniteMatchTimeout, wenn kein anwendungsweiter Timeoutwert festgelegt wurde.

Wichtig

Es wird empfohlen, in allen Musterabgleichsvorgängen für reguläre Ausdrücke einen Timeoutwert festzulegen. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke.

Zurück zu Anmerkungen

Konstruktoren

Regex()

Initialisiert eine neue Instanz der Regex-Klasse.

Regex(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der Regex-Klasse mithilfe von serialisierten Daten.

Regex(String)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck.

Regex(String, RegexOptions)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen zum Verändern des Musters.

Regex(String, RegexOptions, TimeSpan)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen, die das Muster und einen Wert ändern, der angibt, wie lange eine Mustervergleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor ein Timeout eintritt.

Felder

capnames

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

caps

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

capsize

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

capslist

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

factory

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

InfiniteMatchTimeout

Gibt an, dass bei einem Mustervergleichsvorgang kein Timeout angewendet werden sollte.

internalMatchTimeout

Die maximale Zeit, die ein Mustervergleichsvorgang ausgeführt werden kann, bevor des Timeout eintritt.

pattern

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

roptions

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

Eigenschaften

CacheSize

Ruft die maximale Anzahl von Einträgen im aktuellen statischen Cache für die kompilierten regulären Ausdrücke ab oder legt diese fest.

CapNames

Ruft ein Wörterbuch ab, das Erfassungsgruppen ihren Indexwerten zuordnet, oder legt es fest.

Caps

Ruft ein Wörterbuch ab oder legt es fest, das nummerierte Erfassungsgruppen ihren Indexwerten zuordnet.

MatchTimeout

Ruft das Laufzeitintervall der aktuellen Instanz ab.

Options

Ruft die Optionen ab, die an den Regex-Konstruktor übergeben wurden.

RightToLeft

Ruft einen Wert ab, der angibt, ob der reguläre Ausdruck von rechts nach links sucht.

Methoden

CompileToAssembly(RegexCompilationInfo[], AssemblyName)
Veraltet.

Kompiliert ein oder mehrere angegebene Regex-Objekte in eine benannte Assembly.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])
Veraltet.

Kompiliert ein oder mehrere angegebene Regex-Objekte in eine benannte Assembly mit den angegebenen Attributen.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)
Veraltet.

Kompiliert ein oder mehrere angegebene Regex-Objekte und eine angegebene Ressourcendatei in eine benannte Assembly mit den angegebenen Attributen.

Count(ReadOnlySpan<Char>)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(ReadOnlySpan<Char>, Int32)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(ReadOnlySpan<Char>, String)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(ReadOnlySpan<Char>, String, RegexOptions)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(String)

Durchsucht eine Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(String, String)

Durchsucht eine Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(String, String, RegexOptions)

Durchsucht eine Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(String, String, RegexOptions, TimeSpan)

Durchsucht eine Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

EnumerateMatches(ReadOnlySpan<Char>)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator zurück, um die Übereinstimmungen zu durchlaufen.

EnumerateMatches(ReadOnlySpan<Char>, Int32)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator zurück, um die Übereinstimmungen zu durchlaufen.

EnumerateMatches(ReadOnlySpan<Char>, String)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator zurück, um die Übereinstimmungen zu durchlaufen.

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator zurück, um die Übereinstimmungen zu durchlaufen.

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Durchsucht eine Eingabespanne nach allen Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator zurück, um die Übereinstimmungen zu durchlaufen.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Escape(String)

Escapet einen minimalen Zeichensatz (\, *, +, ?, |, {, [, (,), ^, $, ., #und Leerzeichen), indem sie durch ihre Escapecodes ersetzt werden. Damit wird die Engine für reguläre Ausdrücke angewiesen, diese Zeichen als Literale statt als Metazeichen zu interpretieren.

Finalize()

Dieser Member überschreibt Finalize(). Das zugehörige Thema enthält möglicherweise eine umfassendere Dokumentation.

Gibt einem Object Gelegenheit zu dem Versuch, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor das Object von der Garbage Collection freigegeben wird.

GetGroupNames()

Gibt ein Array der Namen von Erfassungsgruppen für den regulären Ausdruck zurück.

GetGroupNumbers()

Gibt ein Array der Nummern von Erfassungsgruppen zurück, die den Gruppennamen in einem Array entsprechen.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
GroupNameFromNumber(Int32)

Ruft den Gruppennamen ab, der der angegebenen Gruppennummer entspricht.

GroupNumberFromName(String)

Gibt die Gruppennummer zurück, die dem angegebenen Gruppennamen entspricht.

InitializeReferences()

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

IsMatch(ReadOnlySpan<Char>)

Gibt an, ob der im Regex-Konstruktor angegebene reguläre Ausdruck eine Übereinstimmung in einer angegebenen Eingabespanne findet.

IsMatch(ReadOnlySpan<Char>, Int32)

Gibt an, ob der im Regex-Konstruktor angegebene reguläre Ausdruck eine Übereinstimmung in einer angegebenen Eingabespanne findet.

IsMatch(ReadOnlySpan<Char>, String)

Gibt an, ob der angegebene reguläre Ausdruck eine Übereinstimmung in der angegebenen Eingabespanne findet.

IsMatch(ReadOnlySpan<Char>, String, RegexOptions)

Gibt an, ob der angegebene reguläre Ausdruck unter Verwendung der angegebenen Abgleichsoptionen eine Übereinstimmung in der angegebenen Eingabespanne findet.

IsMatch(ReadOnlySpan<Char>, String, RegexOptions, TimeSpan)

Gibt an, ob der angegebene reguläre Ausdruck eine Übereinstimmung in der angegebenen Eingabespanne findet, wobei die angegebenen Übereinstimmungsoptionen und das angegebene Timeoutintervall verwendet werden.

IsMatch(String)

Gibt an, ob der im Regex-Konstruktor angegebene reguläre Ausdruck eine Übereinstimmung in einer angegebenen Eingabezeichenfolge findet.

IsMatch(String, Int32)

Gibt an, ob der im Regex-Konstruktor angegebene reguläre Ausdruck ab der angegebenen Anfangsposition eine Übereinstimmung in der angegebenen Eingabezeichenfolge findet.

IsMatch(String, String)

Gibt an, ob der reguläre Ausdruck eine Übereinstimmung in der angegebenen Eingabezeichenfolge findet.

IsMatch(String, String, RegexOptions)

Gibt an, ob der angegebene reguläre Ausdruck unter Verwendung der angegebenen Übereinstimmungsoptionen eine Übereinstimmung in der angegebenen Eingabezeichenfolge findet.

IsMatch(String, String, RegexOptions, TimeSpan)

Gibt an, ob der angegebene reguläre Ausdruck unter Verwendung der angegebenen Übereinstimmungsoptionen und des angegebenen Timeoutintervalls eine Übereinstimmung in der angegebenen Eingabezeichenfolge findet.

Match(String)

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des im Regex-Konstruktor angegebenen regulären Ausdrucks.

Match(String, Int32)

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge.

Match(String, Int32, Int32)

Sucht beginnend an der angegebenen Anfangsposition in der Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks und sucht nur nach der angegebenen Anzahl von Zeichen.

Match(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.

Match(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.

Match(String, String, RegexOptions, TimeSpan)

Durchsucht die Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen und des angegebenen Timeoutintervalls nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.

Matches(String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks.

Matches(String, Int32)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge.

Matches(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines angegebenen regulären Ausdrucks.

Matches(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach allen Vorkommen des angegebenen regulären Ausdrucks.

Matches(String, String, RegexOptions, TimeSpan)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen und des angegebenen Timeoutintervalls nach allen Vorkommen des angegebenen regulären Ausdrucks.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
Replace(String, MatchEvaluator)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.

Replace(String, MatchEvaluator, Int32)

Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.

Replace(String, MatchEvaluator, Int32, Int32)

Ersetzt in einer angegebenen Eingabeteilzeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.

Replace(String, String)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit dem Muster für den regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.

Replace(String, String, Int32)

Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine angegebene Ersetzungszeichenfolge.

Replace(String, String, Int32, Int32)

Ersetzt in einer angegebenen Eingabeteilzeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine angegebene Ersetzungszeichenfolge.

Replace(String, String, MatchEvaluator)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.

Replace(String, String, MatchEvaluator, RegexOptions)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Teilzeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.

Replace(String, String, String)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.

Replace(String, String, String, RegexOptions)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.

Replace(String, String, String, RegexOptions, TimeSpan)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.

Split(String)

Teilt die angegebene Eingabezeichenfolge an den Positionen in ein Array von Teilzeichenfolgen auf, die durch ein im Regex-Konstruktor angegebenes Muster für einen regulären Ausdruck definiert werden.

Split(String, Int32)

Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden.

Split(String, Int32, Int32)

Teilt die angegebene Eingabezeichenfolge höchstens die angegebene Anzahl von Malen an den Positionen in ein Array von Teilzeichenfolgenketten auf, die durch einen im Regex-Konstruktor angegebenen regulären Ausdruck definiert werden. Die Suche nach dem Muster des regulären Ausdrucks beginnt bei einer angegebenen Zeichenposition in der Eingabezeichenfolge.

Split(String, String)

Teilt eine Eingabezeichenfolge an den durch ein reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.

Split(String, String, RegexOptions)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.

Split(String, String, RegexOptions, TimeSpan)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.

ToString()

Gibt das Muster eines regulären Ausdrucks zurück, das an den Regex-Konstruktor übergeben wurde.

Unescape(String)

Konvertiert alle Escapezeichen in der Eingabezeichenfolge.

UseOptionC()

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

UseOptionR()

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.

ValidateMatchTimeout(TimeSpan)

Überprüft, ob ein Timeoutintervall innerhalb eines akzeptablen Bereichs liegt.

Explizite Schnittstellenimplementierungen

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Füllt ein SerializationInfo-Objekt mit den Daten, die erforderlich sind, um das aktuelle Regex-Objekt zu deserialisieren.

Gilt für

Threadsicherheit

Die Regex Klasse ist unveränderlich (schreibgeschützt) und threadsicher. Regex -Objekte können für jeden Thread erstellt und zwischen Threads freigegeben werden. Weitere Informationen finden Sie unter Threadsicherheit.

Siehe auch