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+) Entspricht mindestens einem Wortzeichen bis zu einer Wortgrenze. Benennen Sie diese erfasste Gruppe word.
\s+ Übereinstimmung mit mindestens einem Leerzeichen finden.
(\k<word>) Stimmen Sie mit der erfassten Gruppe überein, die benannt wordist.
\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

Im folgenden Beispiel wird die Verwendung eines regulären Ausdrucks veranschaulicht, um zu überprüfen, ob eine Zeichenfolge entweder einen Währungswert darstellt oder über das richtige Format verfügt, um einen Währungswert darzustellen. In diesem Fall wird der reguläre Ausdruck dynamisch aus der NumberFormatInfo.CurrencyDecimalSeparatorNumberFormatInfo.NegativeSignCurrencyDecimalDigitsNumberFormatInfo.CurrencySymbolNumberFormatInfo.PositiveSign aktuellen Kultur des Benutzers erstellt. Wenn die aktuelle Kultur des Systems en-US ist, lautet ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$der resultierende reguläre Ausdruck . 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.
[\+-]? Entspricht null oder einem Vorkommen des positiven Zeichens oder des 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.
\.? Übereinstimmung mit null oder einem Dezimalkommasymbol.
\d{2}? Stimmen Sie zwei Dezimalstellen null oder einmal überein.
(\d*\.?\d{2}?){1} Passen Sie das Muster der integralen und bruchalen Ziffern an, die durch ein Dezimalkommasymbol mindestens einmal getrennt sind.
$ Entspricht dem Ende der Zeichenfolge.

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 durch die Eigenschaft der aktuellen Kultur CurrencyDecimalDigits definierten Bruchstellen aufweist.

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

public class Example
{
   public static void Main()
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // 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}$";
      
      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("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// The example displays the following output:
//       -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 = NumberFormatInfo.CurrentInfo

      ' 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}$"
      
      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:
'       -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 wir nicht, ob das Währungssymbol der aktuellen Kultur, das Dezimalzeichen oder das positive und negative Zeichen vom Regulären Ausdrucksmodul als Reguläre Ausdruckssprachoperatoren falsch interpretiert werden. Um eine Fehlinterpretation zu verhindern, übergibt das Beispiel jede dynamisch generierte Zeichenfolge an die Escape Methode.

Hinweise

Die Regex Klasse stellt das reguläre Ausdrucksmodul des .NET Framework dar. Es kann verwendet werden, um große Textmengen schnell zu analysieren, um bestimmte Zeichenmuster zu finden; zum Extrahieren, Bearbeiten, Ersetzen oder Löschen von Textunterzeichenfolgen; und um die extrahierten Zeichenfolgen zu einer Auflistung hinzuzufügen, um einen Bericht zu generieren.

Hinweis

Wenn Ihr primäres Interesse besteht, eine Zeichenfolge zu überprüfen, indem Sie bestimmen, 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 regulärer Ausdruckssprache dokumentiert ist – 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 des regulären Ausdrucks entspricht, oder das Identifizieren einer Mustervergleichung.

Hinweis

Einige gängige reguläre Ausdrucksmuster finden Sie in den Beispielen für reguläre Ausdrücke. Es gibt auch eine Reihe von Onlinebibliotheken regulärer Ausdrucksmuster, z. B. die von 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 vs. String-Methoden

Die System.String Klasse enthält mehrere Such- und Vergleichsmethoden, mit denen Sie Musterabgleich mit Text durchführen können. Beispielsweise bestimmen die String.Contains, String.EndsWithund String.StartsWith Methoden, ob eine Zeichenfolgeninstanz eine angegebene Teilzeichenfolge enthält; und die String.IndexOf, String.IndexOfAny, String.LastIndexOf, und 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.

Zurück zu Anmerkungen

Statische und Instanzmethoden

Nachdem Sie ein reguläres Ausdrucksmuster definiert haben, können Sie es dem regulären Ausdrucksmodul auf zwei Arten bereitstellen:

  • Durch Instanziieren eines Regex Objekts, das den regulären Ausdruck darstellt. Dazu übergeben Sie das Muster des regulären Ausdrucks 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 Text angeben, um nach einer static (Shared in Visual Basic) Regex -Methode zu suchen. Auf diese Weise können Sie einen regulären Ausdruck verwenden, ohne explizit ein Regex Objekt zu erstellen.

Alle Regex Musteridentifikationsmethoden umfassen statische und 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 die Notwendigkeit zu vermeiden, einen einzelnen regulären Ausdruck wiederholt zu kompilieren, speichert das reguläre Ausdrucksmodul die kompilierten regulären Ausdrücke, die in statischen Methodenaufrufen verwendet werden. Daher bieten reguläre Ausdrucksmusterabgleichsmethoden vergleichbare Leistung für statische 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 Instanz- oder statischen Methodenaufrufen verwendet wurden. Ab dem .NET Framework 2.0 werden nur reguläre Ausdrücke, die in statischen Methodenaufrufen verwendet werden, zwischengespeichert.

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 reguläre Ausdrucksmodul 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 suchen. Obwohl das Beispiel einen einzelnen regulären Ausdruck verwendet, 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 die Neukompilierung zu verhindern, sollten Sie ein einzelnes Regex Objekt instanziieren, auf das für alle Code zugegriffen werden kann, auf den sie erforderlich ist, 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()
    

Zurück zu Anmerkungen

Ausführen von regulären Ausdrucksvorgängen

Unabhängig davon, ob Sie ein Regex Objekt instanziieren und seine 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 festzustellen, 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 abgerufen werden, indem sie die Match.NextMatch Methode aufrufen.

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

  • 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 durch den regulären Ausdruck definiert werden.

Zusätzlich zu seinen Musterabgleichsmethoden enthält die Regex Klasse mehrere spezielle Methoden:

  • Die Escape Methode escapet alle Zeichen, die als reguläre Ausdrucksoperatoren 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 reguläre Ausdruckssprache, die erhebliche Leistungsfähigkeit und Flexibilität bei der Musterabgleichung bietet. Die Leistungsfähigkeit und Flexibilität sind jedoch kostenlos: 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äßigen Backtracking basieren, möglicherweise nicht mehr reagieren, wenn sie Text verarbeiten, der fast dem regulären Ausdrucksmuster entspricht. Weitere Informationen zum .NET Regular Expression-Modul finden Sie unter Details zum Regulären Ausdrucksverhalten. Weitere Informationen zu übermäßigem Backtracking finden Sie unter Backtracking.

Ab dem .NET Framework 4.5 können Sie ein Timeoutintervall für reguläre Ausdrucksübereinstimmungen definieren, um eine übermäßige Rückverfolgung zu begrenzen. Je nach regulärem Ausdrucksmuster und Eingabetext kann die Ausführungszeit das angegebene Timeoutintervall überschreiten, es wird jedoch nicht mehr Zeitrückverfolgung als das angegebene Timeoutintervall verbringen. Wenn das reguläre Ausdrucksmodul ausgezeitet ist, löst es eine RegexMatchTimeoutException Ausnahme aus. In den meisten Fällen verhindert dies, dass das reguläre Ausdrucksmodul die Verarbeitungsleistung ausgibt, indem versucht wird, Text abzugleichen, der fast dem regulären Ausdrucksmuster entspricht. Es könnte jedoch auch darauf hinweisen, dass das Timeoutintervall zu niedrig festgelegt wurde oder dass die aktuelle Maschinenlast zu einer allgemeinen Verschlechterung der Leistung geführt 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 Maschinenlast festgelegt ist, können Sie das Timeoutintervall erhöhen und den Abgleichsvorgang wiederholen. Wenn die Ausnahme auftritt, da der reguläre Ausdruck auf übermäßige Rückverfolgung basiert, können Sie davon ausgehen, dass eine Übereinstimmung nicht vorhanden ist, und optional können Sie Informationen protokollieren, die Ihnen beim Ändern des regulären Ausdrucksmusters 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 mit einem matchTimeout Parameter aufrufen. Wenn Sie keinen Timeoutwert explizit festlegen, wird der Standardmäßige Timeoutwert wie folgt bestimmt:

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

  • Wenn kein anwendungsweiter Timeoutwert festgelegt wurde, wird der Wert InfiniteMatchTimeoutverwendet.

Wichtig

Es wird empfohlen, einen Timeoutwert in allen regulären Ausdrucksmusterabgleichsvorgängen 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 einen Eingabebereich für alle Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(ReadOnlySpan<Char>, String)

Durchsucht einen Eingabebereich für alle Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(ReadOnlySpan<Char>, String, RegexOptions)

Durchsucht einen Eingabebereich für alle Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

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

Durchsucht einen Eingabebereich für alle Vorkommen eines regulären Ausdrucks und gibt die Anzahl der Übereinstimmungen zurück.

Count(String)

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

Count(String, String)

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

Count(String, String, RegexOptions)

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

Count(String, String, RegexOptions, TimeSpan)

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

EnumerateMatches(ReadOnlySpan<Char>)

Durchsucht einen Eingabebereich für alle Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator Wert zurück, der über die Übereinstimmungen iteriert wird.

EnumerateMatches(ReadOnlySpan<Char>, String)

Durchsucht einen Eingabebereich für alle Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator Wert zurück, der über die Übereinstimmungen iteriert wird.

EnumerateMatches(ReadOnlySpan<Char>, String, RegexOptions)

Durchsucht einen Eingabebereich für alle Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator Wert zurück, der über die Übereinstimmungen durchlaufen wird.

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

Durchsucht einen Eingabebereich für alle Vorkommen eines regulären Ausdrucks und gibt einen Regex.ValueMatchEnumerator Wert zurück, der über die Übereinstimmungen durchlaufen wird.

Equals(Object)

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

(Geerbt von Object)
Escape(String)

Versieht einen minimalen Satz an Zeichen (\, *, +, ?, |, {, [, (,), ^, $,., # und Leerzeichen) mit Escapezeichen, indem diese durch die jeweils entsprechende Escapesequenz 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 einem angegebenen Eingabebereich 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 eine Übereinstimmung in der angegebenen Eingabespanne mit den angegebenen Abgleichsoptionen findet.

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

Gibt an, ob der angegebene reguläre Ausdruck eine Übereinstimmung im angegebenen Eingabebereich findet, indem die angegebenen Übereinstimmungsoptionen und Timeoutintervalle 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 auf jedem Thread erstellt und zwischen Threads freigegeben werden. Weitere Informationen finden Sie unter Thread Safety.

Siehe auch