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 einen regulären Ausdruck für wiederholte Vorkommen von Wörtern in einer Zeichenfolge zu überprüfen.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 wie in der folgenden Tabelle dargestellt interpretiert werden kann.The regular expression \b(?<word>\w+)\s+(\k<word>)\b can be interpreted as shown in the following table.

MusterPattern BeschreibungDescription
\b Beginnt den Abgleich an einer Wortgrenze.Start the match at a word boundary.
(?<word>\w+) Übereinstimmung mit mindestens einem Wortzeichen bis zu einer Wortgrenze.Match one or more word characters up to a word boundary. Nennen Sie diese erfasste Gruppe word.Name this captured group word.
\s+ Übereinstimmung mit ein oder mehrere Leerzeichen Zeichen.Match one or more white-space characters.
(\k<word>) Die erfasste Gruppe mit dem Namen übereinstimmen word.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
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

Das folgende Beispiel veranschaulicht die Verwendung eines regulären Ausdrucks zu überprüfen, ob eine Zeichenfolge eine Währung darstellt, oder es verfügt über das richtige Format zum Darstellen einer Währung.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 der reguläre Ausdruck wird dynamisch erstellt, aus der NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, und NumberFormatInfo.PositiveSign Eigenschaften für die aktuelle Kultur des Benutzers.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 das System den aktuellen ist Kultur "En-US" ist, ist der resultierende reguläre ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$.If the system's current culture is en-US, the resulting regular expression is ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Wie in der folgenden Tabelle gezeigt, kann dieser reguläre Ausdruck 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.
[\+-]? Übereinstimmung mit keinem oder einem Vorkommen entweder das positiven Vorzeichen oder das negativen Vorzeichen.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.
\$? Übereinstimmung mit keinem oder einem Vorkommen das Dollarzeichen.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.
\.? Übereinstimmung mit keinem oder einem Dezimaltrennzeichen.Match zero or one decimal point symbol.
\d{2}? Übereinstimmung mit zwei Dezimalzahlen 0 (null) oder einem Vorkommen.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} Übereinstimmung mit dem Muster der vor- und Nachkommastellen Ziffern getrennt durch ein Dezimaltrennzeichen mindestens einmal aus.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ Übereinstimmung mit dem Ende der Zeichenfolge.Match the end of the string.

Der reguläre Ausdruck in diesem Fall wird jedoch vorausgesetzt, dass eine gültige Währungszeichenfolge keine Gruppe für Trennzeichensymbole und hat entweder keine Dezimalstellen oder die Anzahl der Dezimalstellen, die von der aktuellen Kultur definiert CurrencyDecimalDigits Eigenschaft.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 die reguläre Ausdrücke in diesem Beispiel wird dynamisch erstellt wurde, wissen nicht zur Entwurfszeit wir, ob das Währungssymbol der aktuellen Kultur, Dezimaltrennzeichen oder positiven und negativen Vorzeichen durch die Engine für reguläre Ausdrücke als reguläre fehlinterpretiert werden können Language-Operatoren für Ausdrücke.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. Im Beispiel wird jede dynamisch generierte Zeichenfolge, die um alle Fehlinterpretationen zu vermeiden, übergeben die Escape Methode.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

Hinweise

Die Regex Klasse stellt die .NET Framework Engine für reguläre Ausdrücke dar.The Regex class represents the .NET Framework's regular expression engine. Es kann verwendet werden, um schnell große Textmengen zur Suche nach bestimmten Zeichenmustern analysieren. zum Extrahieren, bearbeiten, ersetzen oder Löschen von Textzeichenfolgen; und zum Hinzufügen der extrahierten Zeichenfolgen zu einer Auflistung, die 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 Hauptinteresse ist, überprüfen eine Zeichenfolge, indem Sie bestimmen, ob sie einem bestimmten Muster entspricht, können Sie die System.Configuration.RegexStringValidator Klasse.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 verwenden, definieren Sie das Muster, die in einen Textstream zu identifizieren, mit der Syntax, dokumentiert werden sollen Sprachelemente für reguläre Ausdrücke – Kurzübersicht.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 Instanziieren einer Regex Objekt.Next, you can optionally instantiate a Regex object. Schließlich rufen Sie eine Methode, die einige Vorgänge, z. B. Ersetzen von Text, der das Muster für reguläre Ausdrücke entspricht, oder eine Musterübereinstimmung identifizieren ausführt.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 allgemeine 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 der Muster für reguläre Ausdrücke, wie z. B. unter regulären-Expressions.info.There are also a number of online libraries of regular expression patterns, such as the one at Regular-Expressions.info.

Weitere Informationen zur Verwendung der Regex Klasse, finden Sie unter 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

Im Vergleich mit Regex String-MethodenRegex vs. String Methods

Die System.String Klasse enthält mehrere Methoden für den Vergleich und die Suche, die Sie verwenden können, zum Ausführen von Musterabgleich mit Text.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. Z. B. die String.Contains, String.EndsWith, und String.StartsWith Methoden zu ermitteln, ob eine Zeichenfolgeninstanz eine angegebene Teilzeichenfolge enthält und die String.IndexOf, String.IndexOfAny, String.LastIndexOf, und String.LastIndexOfAny Methoden zurück, das Starten die Position einer angegebenen Teilzeichenfolge 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 von 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 der Regex Klasse, wenn Sie nach einem bestimmten Muster in einer Zeichenfolge suchen.Use the Regex class when you are searching for a specific pattern in a string. Weitere Informationen und Beispiele finden Sie unter reguläre Ausdrücke von .NET Framework.For more information and examples, see .NET Framework Regular Expressions.

Zurück zu "Hinweise"Back to Remarks

Statische und InstanzmethodenStatic vs. Instance Methods

Nach dem Muster eines regulären Ausdrucks definieren, können Sie es für die Engine für reguläre Ausdrücke in eine von zwei Arten bereitstellen:After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • Durch die Instanziierung einer Regex -Objekt, das den regulären Ausdruck darstellt.By instantiating a Regex object that represents the regular expression. Dazu übergeben Sie das Muster des regulären Ausdrucks zu einer Regex Konstruktor.To do this, you pass the regular expression pattern to a Regex constructor. Ein Regex -Objekt unveränderlich ist; beim Instanziieren einer Regex Objekt mit einem regulären Ausdruck, dass reguläre Ausdrücke des Objekts nicht geändert werden kann.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • Durch das Angeben der reguläre Ausdruck und der Text, der zum Suchen einer static (Shared in Visual Basic) Regex Methode.By supplying both the regular expression and the text to search to a static (Shared in Visual Basic) Regex method. Dadurch können Sie einen regulären Ausdruck verwenden, ohne explizite Erstellung einer Regex Objekt.This enables you to use a regular expression without explicitly creating a Regex object.

Alle Regex Identifikation Mustermethoden umfassen sowohl statische und der Instanz von Überladungen.All Regex pattern identification methods include both static and instance overloads.

Ein bestimmtes Muster kann von der Engine für reguläre Ausdrücke muss kompiliert werden, bevor das Muster verwendet werden kann.The regular expression engine must compile a particular pattern before the pattern can be used. Da Regex Objekte sind unveränderlich, dies ist eine einmalige Prozedur, die auftritt, wenn eine Regex 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 einen einzelnen regulären Ausdruck wiederholt kompiliert werden muss, zu beseitigen, speichert die Engine für reguläre Ausdrücke die kompilierte reguläre Ausdrücke, die in statischen Methodenaufrufen verwendet.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. Daher bieten reguläre Ausdrucksmuster-Vergleichsmethoden an vergleichbare Leistung für statische und Instanzmethoden.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

Wichtig

In .NET Framework-Versionen 1.0 und 1.1, alle kompilierten regulären Ausdrücken klicken Sie, ob sie in der Instanz oder eine statische Methode verwendet wurden aufruft, zwischengespeichert 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. Ab .NET Framework 2.0, werden nur in statischen Methodenaufrufen verwendete reguläre Ausdrücke zwischengespeichert werden.Starting with the .NET Framework 2.0, only regular expressions used in static method calls are cached.

Allerdings kann das Zwischenspeichern Leistung in den folgenden zwei Fällen beeinträchtigen:However, caching can adversely affect performance in the following two cases:

  • Wenn Sie statische Methodenaufrufe mit einer großen Anzahl von regulären Ausdrücken verwenden.When you use static method calls with a large number of regular expressions. In der Standardeinstellung speichert die Engine für reguläre Ausdrücke die 15 zuletzt verwendeten statischen regulären Ausdrücken.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ücken 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 erhöhen die Regex.CacheSize Eigenschaft.To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Bei der Instanziierung neue Regex Objekte mit regulären Ausdrücken, 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 zum doppelte Wörter in einen Textstream gesucht werden soll.For example, the following code defines a regular expression to locate duplicated words in a text stream. Obwohl das Beispiel einen einzelnen regulären Ausdruck verwendet wird, instanziiert ein neues Regex zu jeder Zeile des Texts zu verarbeitende Objekt.Although the example uses a single regular expression, it instantiates a new Regex object to process each line of text. Dadurch wird die Neukompilierung des regulären Ausdrucks mit 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 zu verhindern, dass eine Neukompilierung, instanziieren Sie ein einzelnes Regex -Objekt, das kann zugegriffen werden, für den gesamten Code, der notwendig ist, wie die folgende umgeschriebene 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 "Hinweise"Back to Remarks

Ausführen von Vorgängen für reguläre AusdrückePerforming Regular Expression Operations

Gibt an, ob Sie instanziieren möchten eine Regex Objekt und seine Methoden aufrufen oder statische Methoden, die Regex -Klasse bietet die folgende Mustervergleichs-Funktionen: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:

  • Die Überprüfung einer Übereinstimmung.Validation of a match. Rufen Sie die IsMatch Methode, um zu bestimmen, ob eine Übereinstimmung vorhanden ist.You call the IsMatch method to determine whether a match is present.

  • Abrufen von einer einzelnen Übereinstimmung sucht.Retrieval of a single match. Rufen Sie die Match Methode zum Abrufen einer Match Objekt, das die erste Übereinstimmung in einer Zeichenfolge oder 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 abgerufen werden können, durch den Aufruf der Match.NextMatch Methode.Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • Abrufen von alle Übereinstimmungen.Retrieval of all matches. Rufen Sie die Matches Methode zum Abrufen einer System.Text.RegularExpressions.MatchCollection Objekt, das alle Übereinstimmungen gefunden werden, in einer Zeichenfolge oder Teil einer Zeichenfolge darstellt.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.

  • Ersetzt übereinstimmenden Text.Replacement of matched text. Rufen Sie die Replace Methode, um übereinstimmende Text ersetzt werden soll.You call the Replace method to replace matched text. Der Ersatztext kann auch von einem regulären Ausdruck definiert werden.The replacement text can also be defined by a regular expression. Darüber hinaus einige der Replace Methoden umfassen eine MatchEvaluator Parameter, der Ihnen ermöglicht, den Ersetzungstext programmgesteuert definieren.In addition, some of the Replace methods include a MatchEvaluator parameter that enables you to programmatically define the replacement text.

  • Die Erstellung eines Zeichenfolgenarrays, die aus Teilen einer Eingabezeichenfolge gebildet wird.Creation of a string array that is formed from parts of an input string. Rufen Sie die Split Methode, um eine Eingabezeichenfolge an den Positionen zu teilen, die mit dem regulären Ausdruck definiert sind.You call the Split method to split an input string at positions that are defined by the regular expression.

Zusätzlich zu seiner Mustervergleichsmethoden die Regex Klasse enthält mehrere spezielle 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 die Eingabezeichenfolge 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 Escape-Zeichen.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. .NET Framework enthält Beispiele für diese spezielle Assemblys in der System.Web.RegularExpressions Namespace.The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

Zurück zu "Hinweise"Back to Remarks

Definieren einen TimeoutwertDefining a Time-Out Value

.NET Framework unterstützt eine voll funktionsfähige reguläre-Sprache, die erhebliche Leistungsstärke und Flexibilität Musterabgleich enthält.The .NET Framework supports a full-featured regular expression language that provides substantial power and flexibility in pattern matching. Aber die Leistungsfähigkeit und Flexibilität mit Nachteilen verbunden: das Risiko einer schlechten Leistung.However, the power and flexibility come at a cost: the risk of poor performance. Reguläre Ausdrücke, die Verschlechterung der Leistung sind erstaunlich leicht zu erstellen.Regular expressions that perform poorly are surprisingly easy to create. In einigen Fällen können reguläre Vorgänge, bei denen übermäßige rückverfolgung angezeigt werden, nicht mehr reagiert beim Verarbeiten von Text, der fast Muster des regulären Ausdrucks übereinstimmt.In 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 zu den .NET Framework-Engine für reguläre Ausdrücke, finden Sie unter Details Verhalten regulärer Ausdrücke.For more information about the .NET Framework regular expression engine, see Details of Regular Expression Behavior. Weitere Informationen über eine übermäßige rückverfolgung finden Sie unter Backtracking.For more information about excessive backtracking, see Backtracking.

Beginnend mit der .NET Framework 4.5.NET Framework 4.5, Sie können ein anderes Timeoutintervall 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 eine Übereinstimmung innerhalb dieses Intervalls nicht identifizieren kann, löst der entsprechende Vorgang aus einem RegexMatchTimeoutException Ausnahme.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 verhindert, dass dies die Engine für reguläre Ausdrücke verarbeitungsleistung verschwendet, indem Sie versuchen, die Text übereinstimmen, der fast Muster des regulären Ausdrucks übereinstimmt.In 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 auch, allerdings hinweisen, dass das Timeoutintervall zu niedrig festgelegt wurde oder die aktuelle computerauslastung eine allgemeine Beeinträchtigung der Leistung verursacht 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 tritt auf, weil das Timeoutintervall zu niedrig festgelegt ist oder aufgrund übermäßiger computerauslastung vorhanden ist, können Sie das Timeoutintervall erhöhen und den Vergleichsvorgang erneut ausführen.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 tritt auf, da der reguläre Ausdruck auf eine übermäßige rückverfolgung angewiesen ist, können Sie davon ausgehen, dass eine Übereinstimmung ist nicht vorhanden, und, optional, Sie können Protokollinformationen, mit denen Sie das Muster des regulären Ausdrucks zu ändern.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 Timeoutintervall festlegen, durch den Aufruf der Regex(String, RegexOptions, TimeSpan) Konstruktor beim Instanziieren Objekt eines regulären Ausdrucks.You can set a time-out interval by calling the Regex(String, RegexOptions, TimeSpan) constructor when you instantiate a regular expression object. Für statische Methoden, können Sie ein Timeoutintervall festlegen, durch den Aufruf einer Überladung einer übereinstimmenden Methode, die eine matchTimeout Parameter.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 nicht explizit einen Timeoutwert festlegen, wird die Timeoutwert wie folgt bestimmt:If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • Ist Sie mithilfe des gesamten Anwendung Timeouts-Wert, wenn eine vorhanden.By using the application-wide time-out value, if one exists. Dies kann jeder Timeoutwert, der für die Anwendungsdomäne, in dem gilt sein der Regex -Objekt instanziiert oder statische Methode aufgerufen wird.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 Timeoutwert der gesamten Anwendung festlegen, durch den Aufruf der AppDomain.SetData Methode zum Zuweisen der angegebene Zeichenfolgendarstellung einer TimeSpan Wert für die Eigenschaft "REGEX_DEFAULT_MATCH_TIMEOUT".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 anwendungsweite Timeoutwert festgelegt wurde.By using the value InfiniteMatchTimeout, if no application-wide time-out value has been set.

Wichtig

Es wird empfohlen, dass Sie einen Timeoutwert in allen reguläre Mustervergleichs-Operationen 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 "Hinweise"Back 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. Regex Objekte können in jedem Thread erzeugt und mehreren Threads gemeinsam genutzt werden.Regex objects can be created on any thread and shared between threads. Weitere Informationen finden Sie unter Threadsicherheit.For more information, see Thread Safety.

Siehe auch