Regex Regex Regex Regex Class

Definition

Stellt einen unveränderlichen regulären Ausdruck dar.Represents an immutable regular expression.

public ref class Regex : System::Runtime::Serialization::ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
    interface ISerializable
Public Class Regex
Implements ISerializable
Vererbung
RegexRegexRegexRegex
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.The following example uses a regular expression to check for repeated occurrences of words in a string. Der reguläre Ausdruck \b(?<word>\w+)\s+(\k<word>)\b kann wie in der folgenden Tabelle dargestellt interpretiert werden.The regular expression \b(?<word>\w+)\s+(\k<word>)\b can be interpreted as shown in the following table.

MusterPattern BeschreibungDescription
\b Die Entsprechung wird an einer Wort Grenze gestartet.Start the match at a word boundary.
(?<word>\w+) Entsprechung für mindestens ein Wort Zeichen bis zu einer Wort Grenze.Match one or more word characters up to a word boundary. Benennen Sie diese erfasste Gruppe word.Name this captured group word.
\s+ Entspricht einem oder mehreren Leerzeichen.Match one or more white-space characters.
(\k<word>) Entspricht der erfassten Gruppe mit dem wordNamen.Match the captured group that is named word.
\b Übereinstimmung mit einer Wortgrenze.Match a word boundary.
#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 50 and 54
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 50 and 54

Im folgenden Beispiel wird veranschaulicht, wie ein regulärer Ausdruck verwendet wird, um zu überprüfen, ob eine Zeichenfolge entweder einen Währungswert darstellt oder das richtige Format aufweist, um einen Währungswert darzustellen.The following example illustrates the use of a regular expression to check whether a string either represents a currency value or has the correct format to represent a currency value. In diesem Fall wird der reguläre NumberFormatInfo.CurrencyDecimalSeparatorAusdruck dynamisch aus den Eigenschaften, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSignund NumberFormatInfo.PositiveSign für die aktuelle Kultur des Benutzers erstellt.In this case, the regular expression is built dynamically from the NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, and NumberFormatInfo.PositiveSign properties for the user's current culture. Wenn die aktuelle Kultur des Systems "en-US" ist, ist ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$der resultierende reguläre Ausdruck.If the system's current culture is en-US, the resulting regular expression is ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Dieser reguläre Ausdruck kann wie in der folgenden Tabelle dargestellt interpretiert werden.This regular expression can be interpreted as shown in the following table.

MusterPattern BeschreibungDescription
^ Beginnen Sie am Anfang der Zeichenfolge.Start at the beginning of the string.
\s* Sucht nach 0 (null) oder mehr Leerzeichen.Match zero or more white-space characters.
[\+-]? Entspricht keinem oder einem Vorkommen des positiven Zeichens oder des negativen Zeichens.Match zero or one occurrence of either the positive sign or the negative sign.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.Match zero or one white-space character.
\$? Sucht nach 0 (null) oder einem Vorkommen des Dollar Zeichens.Match zero or one occurrence of the dollar sign.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.Match zero or one white-space character.
\d* 0 (null) oder mehr Dezimalstellen sollen übereinstimmen.Match zero or more decimal digits.
\.? Entsprechung für NULL oder ein Dezimaltrennzeichen.Match zero or one decimal point symbol.
\d{2}? Entsprechung für zwei Dezimalziffern NULL oder einmal.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} Vergleichen Sie das Muster von ganzzahligen und Bruch Ziffern, die durch ein Dezimaltrennzeichen getrennt sind, mindestens einmal.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ Entsprechung für das Ende der Zeichenfolge.Match the end of the string.

In diesem Fall geht der reguläre Ausdruck davon aus, dass eine gültige Währungs Zeichenfolge keine Gruppen Trennzeichen enthält, und dass Sie entweder keine Dezimalstellen oder die Anzahl der von der- CurrencyDecimalDigits Eigenschaft der aktuellen Kultur definierten Bruch Ziffern aufweist.In this case, the regular expression assumes that a valid currency string does not contain group separator symbols, and that it has either no fractional digits or the number of fractional digits defined by the current culture's CurrencyDecimalDigits property.

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 der aktuellen Kultur, das Dezimalzeichen oder positive und negative Vorzeichen von der Engine für reguläre Ausdrücke als regulär interpretiert werden können. Ausdrucks sprach Operatoren.Because the regular expression in this example is built dynamically, we do not know at design time whether the current culture's currency symbol, decimal sign, or positive and negative signs might be misinterpreted by the regular expression engine as regular expression language operators. Um eine Fehlinterpretation zu vermeiden, übergibt das Beispiel jede dynamisch generierte Zeichenfolge Escape an die-Methode.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Hinweise

Die Regex -Klasse stellt die Engine für reguläre Ausdrücke des .NET Framework dar.The Regex class represents the .NET Framework's regular expression engine. Sie kann verwendet werden, um schnell große Mengen an Text zu analysieren, um nach bestimmten Zeichen Mustern zu suchen. So extrahieren, bearbeiten, ersetzen oder löschen Sie Text Teil Zeichenfolgen und zum Hinzufügen der extrahierten Zeichen folgen zu einer Auflistung, um einen Bericht zu generieren.It can be used to quickly parse large amounts of text to find specific character patterns; to extract, edit, replace, or delete text substrings; and to add the extracted strings to a collection to generate a report.

Hinweis

Wenn Ihr primäres Interesse darin besteht, eine Zeichenfolge zu validieren, indem Sie feststellen, ob Sie einem System.Configuration.RegexStringValidator bestimmten Muster entspricht, können Sie die-Klasse verwenden.If your primary interest is to validate a string by determining whether it conforms to a particular pattern, you can use the System.Configuration.RegexStringValidator class.

Um reguläre Ausdrücke zu verwenden, definieren Sie das Muster, das Sie in einem Textstream identifizieren möchten, mithilfe der Syntax, die unter Sprache für reguläre Ausdrücke (kurzÜbersicht) dokumentiert ist.To use regular expressions, you define the pattern that you want to identify in a text stream by using the syntax documented in Regular Expression Language - Quick Reference. Als nächstes können Sie optional ein Regex -Objekt instanziieren.Next, you can optionally instantiate a Regex object. Zum Schluss wird eine Methode aufgerufen, 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 Übereinstimmung.Finally, you call a method that performs some operation, such as replacing text that matches the regular expression pattern, or identifying a pattern match.

Hinweis

Einige gängige Muster für reguläre Ausdrücke finden Sie unter Beispiele für reguläre Ausdrücke.For some common regular expression patterns, see Regular Expression Examples. Es gibt auch eine Reihe von Online Bibliotheken von Mustern für reguläre Ausdrücke, z. b. die in Regular-Expressions.info.There are also a number of online libraries of regular expression patterns, such as the one at Regular-Expressions.info.

Weitere Informationen zum Verwenden der Regex -Klasse finden Sie in den folgenden Abschnitten in diesem Thema:For more information about using the Regex class, see the following sections in this topic:

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:For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Kurzübersicht im Word-Format (.docx)Quick Reference in Word (.docx) format
Kurzübersicht im PDF-Format (.pdf)Quick Reference in PDF (.pdf) format

Regex im Vergleich zu Zeichen folgen MethodenRegex vs. String Methods

Die System.String -Klasse enthält mehrere Such-und Vergleichsmethoden, die Sie verwenden können, um Muster Vergleiche mit Text auszuführen.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Beispielsweise bestimmen die String.ContainsMethoden String.EndsWith, und String.StartsWith , ob eine Zeichen folgen Instanz eine angegebene Teil Zeichenfolge enthält, String.IndexOfund String.IndexOfAnydie String.LastIndexOfMethoden, String.LastIndexOfAny , und geben den Anfang zurück. die Position einer angegebenen Teil Zeichenfolge in einer Zeichenfolge.For example, the String.Contains, String.EndsWith, and String.StartsWith methods determine whether a string instance contains a specified substring; and the String.IndexOf, String.IndexOfAny, String.LastIndexOf, and String.LastIndexOfAny methods return the starting position of a specified substring in a string. Verwenden Sie die Methoden der System.String -Klasse, wenn Sie nach einer bestimmten Zeichenfolge suchen.Use the methods of the System.String class when you are searching for a specific string. Verwenden Sie Regex die-Klasse, wenn Sie in einer Zeichenfolge nach einem bestimmten Muster suchen.Use the Regex class when you are searching for a specific pattern in a string. Weitere Informationen und Beispiele finden Sie unter .NET Framework von regulären Ausdrücken.For more information and examples, see .NET Framework Regular Expressions.

Zurück zu hinweisenBack to Remarks

Statische und InstanzmethodenStatic vs. Instance Methods

Nachdem Sie ein Muster für reguläre Ausdrücke definiert haben, können Sie es auf zweierlei Weise für die Engine für reguläre Ausdrücke bereitstellen:After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • Durch Instanziieren eines Regex -Objekts, das den regulären Ausdruck darstellt.By instantiating a Regex object that represents the regular expression. Zu diesem Zweck übergeben Sie das Muster für reguläre Ausdrücke an einen Regex Konstruktor.To do this, you pass the regular expression pattern to a Regex constructor. 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.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • Indem sowohl der reguläre Ausdruck als auch der Text für die Suche nach static einerShared -Methode ( Regex in Visual Basic) bereitgestellt werden.By supplying both the regular expression and the text to search to a static (Shared in Visual Basic) Regex method. Dies ermöglicht es Ihnen, einen regulären Ausdruck zu verwenden, ohne Regex explizit ein-Objekt zu erstellen.This enables you to use a regular expression without explicitly creating a Regex object.

Alle Regex Muster Identifizierungs Methoden enthalten sowohl statische als auch Instanzüberladungen.All Regex pattern identification methods include both static and instance overloads.

Die Engine für reguläre Ausdrücke muss ein bestimmtes Muster kompilieren, bevor das Muster verwendet werden kann.The regular expression engine must compile a particular pattern before the pattern can be used. Da Regex Objekte unveränderlich sind, handelt es sich hierbei um eine einmalige Prozedur, die auftritt, Regex wenn ein Klassenkonstruktor oder eine statische Methode aufgerufen wird.Because Regex objects are immutable, this is a one-time procedure that occurs when a Regex class constructor or a static method is called. Um zu vermeiden, dass ein einzelner regulärer Ausdruck wiederholt kompiliert werden muss, werden die kompilierten regulären Ausdrücke zwischengespeichert, die in statischen Methoden aufrufen verwendet werden.To eliminate the need to repeatedly compile a single regular expression, the regular expression engine caches the compiled regular expressions used in static method calls. Demzufolge bieten Muster Vergleichsmethoden für reguläre Ausdrücke eine vergleichbare Leistung für statische Methoden und Instanzmethoden.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

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 Instanzen oder statischen Methoden aufrufen verwendet wurden.In the .NET Framework versions 1.0 and 1.1, all compiled regular expressions, whether they were used in instance or static method calls, were cached. Beginnend mit dem .NET Framework 2,0 werden nur reguläre Ausdrücke zwischengespeichert, die in statischen Methoden aufrufen verwendet werden.Starting with the .NET Framework 2.0, only regular expressions used in static method calls are cached.

Das Zwischenspeichern kann sich jedoch in den folgenden zwei Fällen negativ auf die Leistung auswirken:However, caching can adversely affect performance in the following two cases:

  • Wenn Sie statische Methodenaufrufe mit einer großen Anzahl regulärer Ausdrücke verwenden.When you use static method calls with a large number of regular expressions. Standardmäßig speichert die Engine für reguläre Ausdrücke die 15 zuletzt verwendeten statischen regulären Ausdrücke zwischen.By default, the regular expression engine caches the 15 most recently used static regular expressions. Wenn Ihre Anwendung mehr als 15 statische reguläre Ausdrücke verwendet, müssen einige reguläre Ausdrücke neu kompiliert werden.If your application uses more than 15 static regular expressions, some regular expressions must be recompiled. Um diese Neukompilierung zu verhindern, können Sie Regex.CacheSize die-Eigenschaft erhöhen.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Wenn Sie neue Regex Objekte mit regulären Ausdrücken instanziieren, die zuvor kompiliert wurden.When you instantiate new Regex objects with regular expressions that have previously been compiled. Der folgende Code definiert z. b. einen regulären Ausdruck, um doppelte Wörter in einem Textstream zu suchen.For example, the following code defines a regular expression to locate duplicated words in a text stream. Obwohl im Beispiel ein einzelner regulärer Ausdruck verwendet wird, wird ein neues Regex -Objekt instanziiert, um jede Textzeile zu verarbeiten.Although the example uses a single regular expression, it instantiates a new Regex object to process each line of text. Dies führt zur erneuten Kompilierung des regulären Ausdrucks bei jeder Iteration der Schleife.This results in the recompilation of the regular expression with each iteration of the loop.

    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 erneute Kompilierung zu verhindern, sollten Sie ein einzelnes Regex Objekt instanziieren, das für den gesamten Code zugänglich ist, der dies erfordert, wie im folgenden umgeschriebenen Beispiel gezeigt.To prevent recompilation, you should instantiate a single Regex object that is accessible to all code that requires it, as shown in the following rewritten example.

    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 hinweisenBack to Remarks

Ausführen von regulären Ausdrucks VorgängenPerforming Regular Expression Operations

Unabhängig davon, ob Sie sich entscheiden, Regex ein-Objekt zu instanziieren und seine Methoden aufzurufen oder statische Methoden aufzurufen, bietet die Regex -Klasse die folgende Muster Vergleichsfunktion:Whether you decide to instantiate a Regex object and call its methods or call static methods, the Regex class offers the following pattern-matching functionality:

  • Überprüfung einer Entsprechung.Validation of a match. Die IsMatch -Methode wird aufgerufen, um zu bestimmen, ob eine Entsprechung vorhanden ist.You call the IsMatch method to determine whether a match is present.

  • Abrufen einer einzelnen Übereinstimmung.Retrieval of a single match. Sie rufen die Match -Methode auf, Match um ein-Objekt abzurufen, das die erste Entsprechung in einer Zeichenfolge oder einem Teil einer Zeichenfolge darstellt.You call the Match method to retrieve a Match object that represents the first match in a string or in part of a string. Nachfolgende Übereinstimmungen können durch Aufrufen der Match.NextMatch -Methode abgerufen werden.Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Abrufen aller Übereinstimmungen.Retrieval of all matches. Sie rufen die Matches -Methode auf, System.Text.RegularExpressions.MatchCollection um ein-Objekt abzurufen, das alle Übereinstimmungen darstellt, die in einer Zeichenfolge oder einem Teil einer Zeichenfolge gefunden wurden.You call the Matches method to retrieve a System.Text.RegularExpressions.MatchCollection object that represents all the matches found in a string or in part of a string.

  • Ersetzung von übereinstimmenden Text.Replacement of matched text. Zum Ersetzen von Replace übereinstimmenden Text wird die-Methode aufgerufen.You call the Replace method to replace matched text. Der Ersetzungstext kann auch durch einen regulären Ausdruck definiert werden.The replacement text can also be defined by a regular expression. Darüber hinaus enthalten einige Replace der Methoden einen MatchEvaluator Parameter, der es Ihnen ermöglicht, den Ersetzungstext Programm gesteuert zu definieren.In addition, some of the Replace methods include a MatchEvaluator parameter that enables you to programmatically define the replacement text.

  • Erstellung eines Zeichen folgen Arrays, das aus Teilen einer Eingabe Zeichenfolge gebildet wird.Creation of a string array that is formed from parts of an input string. Die Split -Methode wird aufgerufen, um eine Eingabe Zeichenfolge an Positionen aufzuteilen, die durch den regulären Ausdruck definiert werden.You call the Split method to split an input string at positions that are defined by the regular expression.

Zusätzlich zu den Methoden für die Muster Übereinstimmung Regex enthält die-Klasse mehrere zweckgebundene Methoden:In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • Die Escape -Methode schützt alle Zeichen, die als Operatoren für reguläre Ausdrücke in einem regulären Ausdruck oder in einer Eingabe Zeichenfolge interpretiert werden können.The Escape method escapes any characters that may be interpreted as regular expression operators in a regular expression or input string.

  • Die Unescape -Methode entfernt diese Escapezeichen.The Unescape method removes these escape characters.

  • Die CompileToAssembly -Methode erstellt eine Assembly, die vordefinierte reguläre Ausdrücke enthält.The CompileToAssembly method creates an assembly that contains predefined regular expressions. Die .NET Framework enthält Beispiele für diese speziellen Assemblys im System.Web.RegularExpressions -Namespace.The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

Zurück zu hinweisenBack to Remarks

Definieren eines Timeout WertsDefining a Time-Out Value

Der .NET Framework unterstützt eine voll ausgestattete Sprache für reguläre Ausdrücke, die eine beträchtliche Leistungsfähigkeit und Flexibilität bei der Muster Übereinstimmung bietet.The .NET Framework supports a full-featured regular expression language that provides substantial power and flexibility in pattern matching. Die Leistungsfähigkeit und Flexibilität sind jedoch kostengünstiger: das Risiko einer schlechten Leistung.However, the power and flexibility come at a cost: the risk of poor performance. Reguläre Ausdrücke, die schlecht funktionieren, sind überraschend leicht zu erstellen.Regular expressions that perform poorly are surprisingly easy to create. 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 mit dem Muster des regulären Ausdrucks übereinstimmtIn some cases, regular expression operations that rely on excessive backtracking can appear to stop responding when they process text that nearly matches the regular expression pattern. Weitere Informationen zum .NET Framework Engine für reguläre Ausdrücke finden Sie unter Details zum Verhalten regulärer Ausdrücke.For more information about the .NET Framework regular expression engine, see Details of Regular Expression Behavior. Weitere Informationen zur übermäßigen Rückverfolgung finden Sie unter Rückverfolgung.For more information about excessive backtracking, see Backtracking.

Beginnend mit .NET Framework 4.5.NET Framework 4.5können Sie ein Timeout Intervall für Übereinstimmungen mit regulären Ausdrücken definieren.Starting with the .NET Framework 4.5.NET Framework 4.5, you can define a time-out interval for regular expression matches. Wenn die Engine für reguläre Ausdrücke keine Übereinstimmung innerhalb dieses Zeitintervalls identifizieren kann, löst der RegexMatchTimeoutException Abgleichsvorgang eine-Ausnahme aus.If the regular expression engine cannot identify a match within this time interval, the matching operation throws a RegexMatchTimeoutException exception. In den meisten Fällen wird dadurch verhindert, dass die Engine für reguläre Ausdrücke die Verarbeitungsleistung verschwendet, indem versucht wird, Text abzugleichen, der fast mit dem Muster des regulären Ausdrucks übereinIn most cases, this prevents the regular expression engine from wasting processing power by trying to match text that nearly matches the regular expression pattern. Es kann jedoch auch darauf hinweisen, dass das Timeout Intervall zu niedrig festgelegt wurde, oder dass die aktuelle Computer Auslastung zu einer Gesamt Leistungsminderung geführt hat.It also could indicate, however, that the timeout interval has been set too low, or that the current machine load has caused an overall degradation in performance.

Wie Sie die Ausnahme behandeln, hängt von der Ursache der Ausnahme ab.How you handle the exception depends on the cause of the exception. Wenn die Ausnahme auftritt, weil das Timeout Intervall zu niedrig oder aufgrund einer übermäßigen Computer Auslastung festgelegt ist, können Sie das Timeout Intervall erhöhen und den Abgleichsvorgang wiederholen.If the exception occurs because the time-out interval is set too low or because of excessive machine load, you can increase the time-out interval and retry the matching operation. Wenn die Ausnahme auftritt, weil der reguläre Ausdruck eine übermäßige Rückverfolgung benötigt, können Sie davon ausgehen, dass keine Entsprechung vorhanden ist, und optional können Sie Informationen protokollieren, die Ihnen bei der Änderung des Musters für reguläre Ausdrücke helfen.If the exception occurs because the regular expression relies on excessive backtracking, you can assume that a match does not exist, and, optionally, you can log information that will help you modify the regular expression pattern.

Sie können ein Timeout Intervall festlegen, indem Sie den Regex(String, RegexOptions, TimeSpan) -Konstruktor aufrufen, wenn Sie ein Objekt für reguläre Ausdrücke instanziieren.You can set a time-out interval by calling the Regex(String, RegexOptions, TimeSpan) constructor when you instantiate a regular expression object. Bei statischen Methoden können Sie ein Timeout Intervall festlegen, indem Sie eine Überladung einer übereinstimmenden Methode aufrufen, die matchTimeout über einen-Parameter verfügt.For static methods, you can set a time-out interval by calling an overload of a matching method that has a matchTimeout parameter. Wenn Sie einen Timeout Wert nicht explizit festlegen, wird der Standard Timeout Wert wie folgt bestimmt:If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • Mit dem Anwendungs weiten Timeout Wert, falls vorhanden.By using the application-wide time-out value, if one exists. Dies kann ein beliebiger Timeout Wert sein, der sich auf die Anwendungsdomäne bezieht, Regex in der das Objekt instanziiert wird, oder der Aufruf der statischen Methode erfolgt.This can be any time-out value that applies to the application domain in which the Regex object is instantiated or the static method call is made. Sie können den Anwendungs weiten Timeout Wert festlegen, indem Sie die AppDomain.SetData -Methode aufrufen, um die Zeichen folgen Darstellung TimeSpan eines Werts der "REGEX_DEFAULT_MATCH_TIMEOUT"-Eigenschaft zuzuweisen.You can set the application-wide time-out value by calling the AppDomain.SetData method to assign the string representation of a TimeSpan value to the "REGEX_DEFAULT_MATCH_TIMEOUT" property.

  • Mit dem Wert InfiniteMatchTimeout, wenn kein Anwendungs weites Timeout Wert festgelegt wurde.By using the value InfiniteMatchTimeout, if no application-wide time-out value has been set.

Wichtig

Es wird empfohlen, dass Sie einen Timeout Wert in allen Vorgängen für Muster Vergleiche mit regulären Ausdrücken festlegen.We recommend that you set a time-out value in all regular expression pattern-matching operations. Weitere Informationen finden Sie unter bewährte Methoden für reguläre Ausdrücke.For more information, see Best Practices for Regular Expressions.

Zurück zu hinweisenBack to Remarks

Konstruktoren

Regex() Regex() Regex() Regex()

Initialisiert eine neue Instanz der Regex-Klasse.Initializes a new instance of the Regex class.

Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext) Regex(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der Regex-Klasse mithilfe von serialisierten Daten.Initializes a new instance of the Regex class by using serialized data.

Regex(String) Regex(String) Regex(String) Regex(String)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck.Initializes a new instance of the Regex class for the specified regular expression.

Regex(String, RegexOptions) Regex(String, RegexOptions) Regex(String, RegexOptions) Regex(String, RegexOptions)

Initialisiert eine neue Instanz der Regex-Klasse für den angegebenen regulären Ausdruck mit Optionen zum Verändern des Musters.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern.

Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan) Regex(String, RegexOptions, TimeSpan) 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.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern and a value that specifies how long a pattern matching method should attempt a match before it times out.

Felder

capnames capnames capnames capnames

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

caps caps caps caps

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

capsize capsize capsize capsize

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

capslist capslist capslist capslist

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

factory factory factory factory

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

InfiniteMatchTimeout InfiniteMatchTimeout InfiniteMatchTimeout InfiniteMatchTimeout

Gibt an, dass bei einem Mustervergleichsvorgang kein Timeout angewendet werden sollte.Specifies that a pattern-matching operation should not time out.

internalMatchTimeout internalMatchTimeout internalMatchTimeout internalMatchTimeout

Die maximale Zeit, die ein Mustervergleichsvorgang ausgeführt werden kann, bevor des Timeout eintritt.The maximum amount of time that can elapse in a pattern-matching operation before the operation times out.

pattern pattern pattern pattern

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

roptions roptions roptions roptions

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

Eigenschaften

CacheSize CacheSize CacheSize 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.Gets or sets the maximum number of entries in the current static cache of compiled regular expressions.

CapNames CapNames CapNames CapNames

Ruft ein Wörterbuch ab, das Erfassungsgruppen ihren Indexwerten zuordnet, oder legt es fest.Gets or sets a dictionary that maps named capturing groups to their index values.

Caps Caps Caps Caps

Ruft ein Wörterbuch ab oder legt es fest, das nummerierte Erfassungsgruppen ihren Indexwerten zuordnet.Gets or sets a dictionary that maps numbered capturing groups to their index values.

MatchTimeout MatchTimeout MatchTimeout MatchTimeout

Ruft das Laufzeitintervall der aktuellen Instanz ab.Gets the time-out interval of the current instance.

Options Options Options Options

Ruft die Optionen ab, die an den Regex-Konstruktor übergeben wurden.Gets the options that were passed into the Regex constructor.

RightToLeft RightToLeft RightToLeft RightToLeft

Ruft einen Wert ab, der angibt, ob der reguläre Ausdruck von rechts nach links sucht.Gets a value that indicates whether the regular expression searches from right to left.

Methoden

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

Kompiliert ein oder mehrere angegebene Regex-Objekte in eine benannte Assembly.Compiles one or more specified Regex objects to a named assembly.

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

Kompiliert ein oder mehrere angegebene Regex-Objekte in eine benannte Assembly mit den angegebenen Attributen.Compiles one or more specified Regex objects to a named assembly with the specified attributes.

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

Kompiliert ein oder mehrere angegebene Regex-Objekte und eine angegebene Ressourcendatei in eine benannte Assembly mit den angegebenen Attributen.Compiles one or more specified Regex objects and a specified resource file to a named assembly with the specified attributes.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Escape(String) Escape(String) Escape(String) Escape(String)

Versieht einen minimalen Satz an Zeichen (\, *, +, ?, |, {, [, (,), ^, $,., # und Leerzeichen) mit Escapezeichen, indem diese durch die jeweils entsprechende Escapesequenz ersetzt werden.Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $, ., #, and white space) by replacing them with their escape codes. Damit wird die Engine für reguläre Ausdrücke angewiesen, diese Zeichen als Literale statt als Metazeichen zu interpretieren.This instructs the regular expression engine to interpret these characters literally rather than as metacharacters.

Finalize() Finalize() Finalize() Finalize()

Dieser Member überschreibt Finalize(). Das zugehörige Thema enthält möglicherweise eine umfassendere Dokumentation.This member overrides Finalize(), and more complete documentation might be available in that topic.

Gibt einem Object Gelegenheit zu dem Versuch, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor das Object von der Garbage Collection freigegeben wird.Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.

GetGroupNames() GetGroupNames() GetGroupNames() GetGroupNames()

Gibt ein Array der Namen von Erfassungsgruppen für den regulären Ausdruck zurück.Returns an array of capturing group names for the regular expression.

GetGroupNumbers() GetGroupNumbers() GetGroupNumbers() GetGroupNumbers()

Gibt ein Array der Nummern von Erfassungsgruppen zurück, die den Gruppennamen in einem Array entsprechen.Returns an array of capturing group numbers that correspond to group names in an array.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
GroupNameFromNumber(Int32) GroupNameFromNumber(Int32) GroupNameFromNumber(Int32) GroupNameFromNumber(Int32)

Ruft den Gruppennamen ab, der der angegebenen Gruppennummer entspricht.Gets the group name that corresponds to the specified group number.

GroupNumberFromName(String) GroupNumberFromName(String) GroupNumberFromName(String) GroupNumberFromName(String)

Gibt die Gruppennummer zurück, die dem angegebenen Gruppennamen entspricht.Returns the group number that corresponds to the specified group name.

InitializeReferences() InitializeReferences() InitializeReferences() InitializeReferences()

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

IsMatch(String) IsMatch(String) IsMatch(String) IsMatch(String)

Gibt an, ob der im Regex-Konstruktor angegebene reguläre Ausdruck eine Übereinstimmung in einer angegebenen Eingabezeichenfolge findet.Indicates whether the regular expression specified in the Regex constructor finds a match in a specified input string.

IsMatch(String, Int32) IsMatch(String, Int32) IsMatch(String, Int32) 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.Indicates whether the regular expression specified in the Regex constructor finds a match in the specified input string, beginning at the specified starting position in the string.

IsMatch(String, String) IsMatch(String, String) IsMatch(String, String) IsMatch(String, String)

Gibt an, ob der reguläre Ausdruck eine Übereinstimmung in der angegebenen Eingabezeichenfolge findet.Indicates whether the specified regular expression finds a match in the specified input string.

IsMatch(String, String, RegexOptions) IsMatch(String, String, RegexOptions) IsMatch(String, String, RegexOptions) IsMatch(String, String, RegexOptions)

Gibt an, ob der angegebene reguläre Ausdruck unter Verwendung der angegebenen Übereinstimmungsoptionen eine Übereinstimmung in der angegebenen Eingabezeichenfolge findet.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.

IsMatch(String, String, RegexOptions, TimeSpan) IsMatch(String, String, RegexOptions, TimeSpan) IsMatch(String, String, RegexOptions, TimeSpan) 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.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options and time-out interval.

Match(String) Match(String) Match(String) Match(String)

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des im Regex-Konstruktor angegebenen regulären Ausdrucks.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, Int32) Match(String, Int32) Match(String, Int32) Match(String, Int32)

Durchsucht die Eingabezeichenfolge nach dem ersten Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String, Int32, Int32) Match(String, Int32, Int32) Match(String, Int32, Int32) 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.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String) Match(String, String) Match(String, String) Match(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.Searches the specified input string for the first occurrence of the specified regular expression.

Match(String, String, RegexOptions) Match(String, String, RegexOptions) Match(String, String, RegexOptions) Match(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach dem ersten Vorkommen des angegebenen regulären Ausdrucks.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) Match(String, String, RegexOptions, TimeSpan) 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.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Matches(String) Matches(String) Matches(String) Matches(String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks.Searches the specified input string for all occurrences of a regular expression.

Matches(String, Int32) Matches(String, Int32) Matches(String, Int32) Matches(String, Int32)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines regulären Ausdrucks ab der angegebenen Anfangsposition in der Zeichenfolge.Searches the specified input string for all occurrences of a regular expression, beginning at the specified starting position in the string.

Matches(String, String) Matches(String, String) Matches(String, String) Matches(String, String)

Durchsucht die angegebene Eingabezeichenfolge nach allen Vorkommen eines angegebenen regulären Ausdrucks.Searches the specified input string for all occurrences of a specified regular expression.

Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions) Matches(String, String, RegexOptions)

Durchsucht die angegebene Eingabezeichenfolge unter Verwendung der angegebenen Übereinstimmungsoptionen nach allen Vorkommen des angegebenen regulären Ausdrucks.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options.

Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) Matches(String, String, RegexOptions, TimeSpan) 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.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options and time-out interval.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) 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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) 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.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) 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.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit dem Muster für den regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, Int32) Replace(String, String, Int32) Replace(String, String, Int32) 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.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) 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.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) 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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, String, MatchEvaluator, RegexOptions) Replace(String, String, MatchEvaluator, RegexOptions) Replace(String, String, MatchEvaluator, RegexOptions) 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.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) 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.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Replace(String, String, String) Replace(String, String, String) Replace(String, String, String) Replace(String, String, String)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Split(String) Split(String) Split(String) 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.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

Split(String, Int32) Split(String, Int32) Split(String, Int32) 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.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

Split(String, Int32, Int32) Split(String, Int32, Int32) Split(String, Int32, Int32) 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.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. Die Suche nach dem Muster des regulären Ausdrucks beginnt bei einer angegebenen Zeichenposition in der Eingabezeichenfolge.The search for the regular expression pattern starts at a specified character position in the input string.

Split(String, String) Split(String, String) Split(String, String) Split(String, String)

Teilt eine Eingabezeichenfolge an den durch ein reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions) Split(String, String, RegexOptions)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan) Split(String, String, RegexOptions, TimeSpan)

Teilt eine Eingabezeichenfolge an den durch ein angegebenes reguläres Ausdrucksmuster definierten Positionen in ein Array von Teilzeichenfolgen auf.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

ToString() ToString() ToString() ToString()

Gibt das Muster eines regulären Ausdrucks zurück, das an den Regex-Konstruktor übergeben wurde.Returns the regular expression pattern that was passed into the Regex constructor.

Unescape(String) Unescape(String) Unescape(String) Unescape(String)

Konvertiert alle Escapezeichen in der Eingabezeichenfolge.Converts any escaped characters in the input string.

UseOptionC() UseOptionC() UseOptionC() UseOptionC()

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

UseOptionR() UseOptionR() UseOptionR() UseOptionR()

Wird von einem durch die Regex-Methode generierten CompileToAssembly-Objekt verwendet.Used by a Regex object generated by the CompileToAssembly method.

ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan) ValidateMatchTimeout(TimeSpan)

Überprüft, ob ein Timeoutintervall innerhalb eines akzeptablen Bereichs liegt.Checks whether a time-out interval is within an acceptable range.

Explizite Schnittstellenimplementierungen

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Füllt ein SerializationInfo-Objekt mit den Daten, die erforderlich sind, um das aktuelle Regex-Objekt zu deserialisieren.Populates a SerializationInfo object with the data necessary to deserialize the current Regex object.

Gilt für:

Threadsicherheit

Die Regex Klasse ist unveränderlich (schreibgeschützt) und Thread sicher.The Regex class is immutable (read-only) and thread safe. RegexObjekte können in jedem Thread erstellt und von Threads gemeinsam genutzt werden.Regex objects can be created on any thread and shared between threads. Weitere Informationen finden Sie unter Thread Sicherheit.For more information, see Thread Safety.

Siehe auch