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+) Übereinstimmung mit einem oder mehreren Wortzeichen bis zu einer Wortgrenze. Nennen Sie diese erfasste Gruppe word .
\s+ Übereinstimmung mit mindestens einem Leerzeichen finden.
(\k<word>) Übereinstimmung mit 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.CurrencyDecimalSeparator Eigenschaften , , , und für die aktuelle Kultur des Benutzers CurrencyDecimalDigits NumberFormatInfo.CurrencySymbol NumberFormatInfo.NegativeSign NumberFormatInfo.PositiveSign erstellt. Wenn die aktuelle Kultur des Systems en-US lautet, ist der resultierende reguläre Ausdruck ^\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 0 (null) oder einem Vorkommen des positiven oder negativen Vorzeichens.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.
\$? Übereinstimmung mit 0 (null) oder einem Vorkommen des Dollarzeichens.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.
\d* 0 (null) oder mehr Dezimalstellen sollen übereinstimmen.
\.? Übereinstimmung mit 0 (null) oder einem Dezimaltrennzeichen.
\d{2}? Übereinstimmung mit zwei Dezimalstellen null oder einmal.
(\d*\.?\d{2}?){1} Übereinstimmung mit dem Muster von ganzzahligen ziffern und Dezimalstellen, die mindestens einmal durch ein Dezimaltrennzeichen getrennt sind.
$ Übereinstimmung mit 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 entweder keine Dezimalstellen oder die Anzahl der durch die -Eigenschaft der aktuellen Kultur definierten Dezimalstellen CurrencyDecimalDigits enthält.

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 zur Entwurfszeit nicht, ob das Währungssymbol, Dezimalzeichen oder positive und negative Zeichen der aktuellen Kultur von der Engine für reguläre Ausdrücke als Sprachoperatoren für reguläre Ausdrücke falsch interpretiert werden können. 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 der .NET Framework dar. Es kann verwendet werden, um große Mengen an Text schnell zu analysieren, um bestimmte Zeichenmuster zu finden. , um Textteilzeichenfolgen 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 eine Zeichenfolge überprüfen möchten, indem Sie ermitteln, 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, mithilfe der Syntax, die in Sprache für reguläre Ausdrücke– Kurzübersicht 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 des regulären Ausdrucks entspricht, oder das Identifizieren einer Muster übereinstimmung.

Hinweis

Einige allgemeine Muster für reguläre Ausdrücke finden Sie unter Beispiele für reguläre Ausdrücke. Es gibt auch eine Reihe von Onlinebibliotheken mit Mustern für reguläre Ausdrücke, z. B. die am 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 im Vergleich zu Zeichenfolgenmethoden

Die System.String -Klasse enthält mehrere Such- und Vergleichsmethoden, mit denen Sie Musterabgleiche mit Text durchführen können. Beispielsweise bestimmen die String.Contains Methoden , und , ob eine String.EndsWith String.StartsWith Zeichenfolgeninstanz eine angegebene Teilzeichenfolge enthält, und die String.IndexOf Methoden , , und geben die String.IndexOfAny String.LastIndexOf String.LastIndexOfAny 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 in einer Zeichenfolge nach einem bestimmten Muster suchen. Weitere Informationen und Beispiele finden Sie unter .NET Framework Reguläre Ausdrücke.

Zurück zu Den Hinweisen

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. Dazu ü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, der an eine static Shared (in Visual Basic)-Methode gesucht werden Regex soll. Dadurch können Sie einen regulären Ausdruck verwenden, ohne explizit ein -Objekt zu Regex erstellen.

Alle Regex Musteridentifikationsmethoden umfassen 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 zu vermeiden, dass ein einzelner regulärer Ausdruck wiederholt kompiliert werden muss, speichert die Engine für reguläre Ausdrücke 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 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 .NET Framework 2.0 werden nur reguläre Ausdrücke zwischengespeichert, die in statischen Methodenaufrufen verwendet werden.

Das Zwischenspeichern 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 doppelte Wörter in einem Textstream zu suchen. Obwohl im Beispiel ein einzelner regulärer Ausdruck verwendet wird, wird ein neues Regex -Objekt instanziiert, um jede Textzeile zu verarbeiten. Dies führt zur Neukompilierung des regulären Ausdrucks bei 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 Den Hinweisen

Ausführen von Vorgängen für reguläre Ausdrücke

Unabhängig davon, ob Sie ein -Objekt instanziieren Regex und dessen Methoden aufrufen oder statische Methoden aufrufen, 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 einem Teil einer Zeichenfolge darstellt. Nachfolgende Übereinstimmungen können durch Aufrufen der -Methode abgerufen Match.NextMatch werden.

  • 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 einem Teil einer Zeichenfolge gefunden wurden.

  • Ersetzung von übereinstimmendem Text. Sie rufen die Replace -Methode auf, um übereinstimmende Texte zu ersetzen. Der Ersetzungstext kann auch durch einen regulären Ausdruck definiert werden. Darüber hinaus enthalten einige der Replace Methoden 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 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 Den Hinweisen

Definieren eines Time-Out Werts

Der .NET Framework unterstützt eine voll funktionsfähige Sprache für reguläre Ausdrücke, die erhebliche Leistungsfähigkeit und Flexibilität beim Musterabgleich bietet. Die Leistungsfähigkeit und Flexibilität hat jedoch ihren Preis: das Risiko einer schlechten Leistung. Reguläre Ausdrücke, die eine schlechte Leistung zeigen, sind überraschend einfach zu erstellen. In einigen Fällen kann es vorkommen, dass Vorgänge für reguläre Ausdrücke, die auf übermäßiger Rückverfolgung basieren, nicht mehr reagieren, wenn sie Text verarbeiten, der fast dem Muster des regulären Ausdrucks entspricht. Weitere Informationen zur .NET Framework Engine für reguläre Ausdrücke finden Sie unter Details zum Verhalten regulärer Ausdrücke. Weitere Informationen zur übermäßigen Rückverfolgung finden Sie unter Rückverfolgung.

Ab .NET Framework 4.5 können Sie ein Time out-Intervall für Übereinstimmungen regulärer Ausdrücke definieren. Wenn die Engine für reguläre Ausdrücke innerhalb dieses Zeitintervalls keine Übereinstimmung identifizieren kann, löst der Abgleichsvorgang eine RegexMatchTimeoutException Ausnahme aus. In den meisten Fällen verhindert dies, dass die Engine für reguläre Ausdrücke Verarbeitungsleistung verspielt, indem versucht wird, Text abzugleichen, der fast mit dem Muster für reguläre Ausdrücke übereinstimmt. Es kann jedoch auch darauf hinweisen, 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 Time out-Intervall zu niedrig oder aufgrund übermäßiger Computerauslastung festgelegt ist, können Sie das Time out-Intervall erhöhen und den Abgleichsvorgang wiederholen. Wenn die Ausnahme auftritt, weil der reguläre Ausdruck von übermäßiger Rückverfolgung abhängt, können Sie davon ausgehen, dass keine Übereinstimmung vorhanden ist. Optional können Sie Informationen protokollieren, mit denen Sie das Muster für reguläre Ausdrücke ändern können.

Sie können ein Time out-Intervall festlegen, indem Sie den Regex(String, RegexOptions, TimeSpan) Konstruktor aufrufen, wenn Sie ein Objekt für reguläre Ausdrücke instanziieren. Bei statischen Methoden können Sie ein Time out-Intervall festlegen, indem Sie eine Überladung einer übereinstimmenden Methode aufrufen, die über einen matchTimeout -Parameter verfügt. Wenn Sie einen Time out-Wert nicht explizit festlegen, wird der Standardtime out-Wert wie folgt bestimmt:

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

  • Mithilfe des Werts InfiniteMatchTimeout , wenn kein anwendungsweiter Time out-Wert festgelegt wurde.

Wichtig

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

Zurück zu Den Hinweisen

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)

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

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

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

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

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

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(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 in jedem Thread erstellt und von Threads gemeinsam genutzt werden. Weitere Informationen finden Sie unter Threadsicherheit.

Siehe auch