Regex.Replace Methode

Definition

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

Überlädt

Replace(String, String, String, RegexOptions)

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

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

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

Replace(String, MatchEvaluator, Int32, Int32)

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

Replace(String, String, MatchEvaluator, RegexOptions)

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

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

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

Replace(String, String, Int32, Int32)

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

Replace(String, String, String)

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

Replace(String, String, MatchEvaluator)

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

Replace(String, String, Int32)

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

Replace(String, MatchEvaluator)

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

Replace(String, String)

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

Replace(String, MatchEvaluator, Int32)

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

Replace(String, String, String, RegexOptions)

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

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options);
public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options);
static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

replacement
String

Die Ersatzzeichenfolge.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input, pattern oder replacement ist null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel wird die Methode verwendet, um die Replace(String, String, String, RegexOptions) lokalen Computer- und Laufwerknamen in einem UNC-Pfad durch einen lokalen Dateipfad zu ersetzen. Der reguläre Ausdruck verwendet die Environment.MachineName Eigenschaft, um den Namen des lokalen Computers einzuschließen, und die Environment.GetLogicalDrives Methode, um die Namen der logischen Laufwerke einzuschließen. Alle Regulären Ausdruckszeichenfolgenvergleiche sind groß- und kleinschreibungsfähig. Um das Beispiel erfolgreich auszuführen, sollten Sie die Literalzeichenfolge "MyMachine" durch ihren lokalen Computernamen ersetzen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Das reguläre Ausdrucksmuster wird durch den folgenden Ausdruck definiert:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

Die folgende Tabelle zeigt, wie das Muster eines regulären Ausdrucks interpretiert wird.

Muster BESCHREIBUNG
\\\\ Übereinstimmen mit zwei aufeinander folgenden Backslashzeichen (\) Da das Backslash-Zeichen als Escapezeichen interpretiert wird, muss jeder Backslash mit einem anderen Backslash escapet werden.
+ Environment.MachineName + Entspricht der Zeichenfolge, die von der Environment.MachineName Eigenschaft zurückgegeben wird.
(?:\.\w+)* Entspricht dem Punkt (.) zeichen gefolgt von einem oder mehreren Wortzeichen. Diese Übereinstimmung kann null oder mehr Zeiten auftreten. Der übereinstimmene Subexpression wird nicht erfasst.
\\ Entspricht einem Backslash (\) Zeichen.
([" + driveNames + "]) Entspricht der Zeichenklasse, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist die erste erfasste Subexpression.
\$ Entspricht dem Literal-Dollarzeichen ($)

Das Ersatzmuster $1 ersetzt die gesamte Übereinstimmung durch den ersten erfassten Subexpression. Das heißt, er ersetzt den UNC-Computer und den Laufwerknamen durch den Laufwerkbuchstaben.

Hinweise

Die statischen Replace Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen regulären Ausdrucksmuster und aufrufen der Instanzmethode Replace.

Der pattern Parameter besteht aus regulären Ausdrucksspracheelementen, die die Zeichenfolge symbolisch beschreiben, die übereinstimmen. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Quick Reference. Wenn Sie den options Parameter angebenRightToLeft, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und wird nach links verschoben. Andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und wird nach rechts verschoben.

Der replacement Parameter gibt die Zeichenfolge an, die jede Übereinstimmung ersetzen inputsoll. replacement kann aus einer beliebigen Kombination von Literaltext und Ersatz bestehen. Das Ersatzmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die der Aufnahmegruppe entspricht, sofern vorhanden, gefolgt von der test Zeichenfolge "b". Das *-Zeichen wird nicht als Metacharacter innerhalb eines Ersatzmusters erkannt.

Hinweis

Ersetzungen sind die einzigen regulären Ausdrucksspracheelemente, die in einem Ersatzmuster erkannt werden. Alle anderen Regulären Ausdrucksspracheelemente, einschließlich Zeichenauslöser, sind nur in regulären Ausdrucksmustern zulässig und werden nicht in Ersatzmustern erkannt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersatzvorgangs das für die Anwendungsdomäne angegebene Timeoutintervall überschreitet, in dem die Methode aufgerufen wird. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert Regex.InfiniteMatchTimeoutangegeben ist, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Methode verwenden, um zu ermitteln, ob die Object.ReferenceEquals Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Diese Methode wird nach einem Intervall, das dem Standard-Timeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird, ausgedauert. Wenn ein Timeout-Wert für die Anwendungsdomäne nicht definiert wurde, wird der Wert verwendet, der die Methode verhindert, dass die Zeitdauer InfiniteMatchTimeoutentfernt wird. Die empfohlene statische Methode zum Ersetzen einer Musterbesprechung ist Replace(String, String, String, RegexOptions, TimeSpan), wodurch Sie das Timeoutintervall festlegen können.

Siehe auch

Gilt für:

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

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

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions, matchTimeout As TimeSpan) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

replacement
String

Die Ersatzzeichenfolge.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

matchTimeout
TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input, pattern oder replacement ist null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

- oder - matchTimeout ist negativ, null oder größer als ca. 24 Tage.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel wird die Methode verwendet, um die Replace(String, String, String, RegexOptions, TimeSpan) lokalen Computer- und Laufwerknamen in einem UNC-Pfad durch einen lokalen Dateipfad zu ersetzen. Der reguläre Ausdruck verwendet die Environment.MachineName Eigenschaft, um den Namen des lokalen Computers und die Environment.GetLogicalDrives Methode einzuschließen, um die Namen der logischen Laufwerke einzuschließen. Alle Regulären Ausdruckszeichenfolgenvergleiche sind groß- und kleinschreibungsfähig, und alle einzelnen Ersatzvorgänge werden nicht gefunden, wenn eine Übereinstimmung in 0,5 Sekunden nicht gefunden werden kann. Um das Beispiel erfolgreich auszuführen, sollten Sie die Literalzeichenfolge "MyMachine" durch ihren lokalen Computernamen ersetzen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         string localPath = null;
         try {
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                      RegexOptions.IgnoreCase,
                                      TimeSpan.FromSeconds(0.5));
            Console.WriteLine("Returned string: " + localPath);
         }
         catch (RegexMatchTimeoutException) {
            Console.WriteLine("The replace operation timed out.");
            Console.WriteLine("Returned string: " + localPath);
            if (uncPath.Equals(localPath)) 
               Console.WriteLine("Equal to original path.");
            else
               Console.WriteLine("Original string: " + uncPath);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Dim localPath As String = Nothing
         Try
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                                               RegexOptions.IgnoreCase,
                                                               TimeSpan.FromSeconds(0.5))
            Console.WriteLine("Returned string: " + localPath)         
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("The replace operation timed out.")
            Console.WriteLine("Returned string: " + localPath)
            If uncPath.Equals(localPath) Then 
               Console.WriteLine("Equal to original path.")
            Else
               Console.WriteLine("Original string: " + uncPath)
            End If
         End Try         
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Das reguläre Ausdrucksmuster wird durch den folgenden Ausdruck definiert:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

Die folgende Tabelle zeigt, wie das Muster eines regulären Ausdrucks interpretiert wird.

Muster BESCHREIBUNG
\\\\ Übereinstimmen mit zwei aufeinander folgenden Backslashzeichen (\) Da das Backslash-Zeichen als Escapezeichen interpretiert wird, muss jeder Backslash mit einem anderen Backslash escapet werden.
+ Environment.MachineName + Entspricht der Zeichenfolge, die von der Environment.MachineName Eigenschaft zurückgegeben wird.
(?:\.\w+)* Entspricht dem Punkt (.) zeichen gefolgt von einem oder mehreren Wortzeichen. Diese Übereinstimmung kann null oder mehr Zeiten auftreten. Der übereinstimmene Subexpression wird nicht erfasst.
\\ Entspricht einem Backslash (\) Zeichen.
([" + driveNames + "]) Entspricht der Zeichenklasse, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist die erste erfasste Subexpression.
\$ Entspricht dem Literal-Dollarzeichen ($)

Das Ersatzmuster $1 ersetzt die gesamte Übereinstimmung durch den ersten erfassten Subexpression. Das heißt, er ersetzt den UNC-Computer und den Laufwerknamen durch den Laufwerkbuchstaben.

Hinweise

Die statischen Replace Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen regulären Ausdrucksmuster und aufrufen der Instanzmethode Replace.

Der pattern Parameter besteht aus regulären Ausdrucksspracheelementen, die die Zeichenfolge symbolisch beschreiben, die übereinstimmen. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Quick Reference. Wenn Sie den options Parameter angebenRightToLeft, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und wird nach links verschoben. Andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und wird nach rechts verschoben.

Der replacement Parameter gibt die Zeichenfolge an, die jede Übereinstimmung ersetzen inputsoll. replacement kann aus einer beliebigen Kombination von Literaltext und Ersatz bestehen. Das Ersatzmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die der Aufnahmegruppe entspricht, sofern vorhanden, gefolgt von der test Zeichenfolge "b". Das *-Zeichen wird nicht als Metacharacter innerhalb eines Ersatzmusters erkannt.

Hinweis

Ersetzungen sind die einzigen regulären Ausdrucksspracheelemente, die in einem Ersatzmuster erkannt werden. Alle anderen Regulären Ausdrucksspracheelemente, einschließlich Zeichenauslöser, sind nur in regulären Ausdrucksmustern zulässig und werden nicht in Ersatzmustern erkannt.

Der matchTimeout Parameter gibt an, wie lange eine Musterabgleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor es ausgeht. Durch festlegen eines Timeoutintervalls wird verhindert, dass reguläre Ausdrücke, die auf übermäßige Backtracking basieren, nicht mehr reagiert, wenn sie Eingaben verarbeiten, die in der Nähe übereinstimmungen enthalten. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke und Backtracking. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standard-Timeout-Wert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Methode verwenden, um zu ermitteln, ob die Object.ReferenceEquals Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen entsprechenden Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie angeben InfiniteMatchTimeout, bietet das reguläre Ausdrucksmodul etwas bessere Leistung. Allerdings sollten Sie Timeouts nur unter den folgenden Bedingungen deaktivieren:

  • Wenn die Eingabe, die von einem regulären Ausdruck verarbeitet wird, aus einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.

  • Wenn das reguläre Ausdrucksmuster gründlich getestet wurde, um sicherzustellen, dass es übereinstimmungen, nicht übereinstimmende und nahe Übereinstimmungen effizient behandelt.

  • Wenn das reguläre Ausdrucksmuster keine Sprachelemente enthält, die bekannt sind, dass eine übermäßige Rückverfolgung beim Verarbeiten einer nahen Übereinstimmung verursacht wird.

Siehe auch

Gilt für:

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.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string
Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

evaluator
MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.

count
Int32

Die maximale Anzahl der Ersetzungen.

startat
Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn keine Entsprechung für das reguläre Ausdrucksmuster in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

input oder evaluator ist null.

startat ist kleiner als 0 (null) oder größer als die Länge von input.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Hinweise

Die Regex.Replace(String, MatchEvaluator, Int32, Int32) Methode ist nützlich, um einen regulären Ausdruck zu ersetzen, wenn eine der folgenden Bedingungen wahr ist:

  • Die Ersatzzeichenfolge kann nicht leicht durch ein reguläres Ausdrucksersetzungsmuster angegeben werden.

  • Die Ersatzzeichenfolge führt zu einer Verarbeitung, die auf der übereinstimmenden Zeichenfolge durchgeführt wurde.

  • Die Ersatzzeichenfolge führt aus der bedingten Verarbeitung.

Die Methode entspricht dem Aufrufen der Methode und dem Übergeben der Regex.Matches(String, Int32) ersten countMatch Objekte in der zurückgegebenen MatchCollection Auflistung an den evaluator Stellvertretung.

Der reguläre Ausdruck ist das Muster, das vom Konstruktor für das aktuelle Regex Objekt definiert wird.

Der evaluator Parameter ist der Stellvertretung für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um dem MatchEvaluator Stellvertretung zu entsprechen.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Ihre benutzerdefinierte Methode gibt eine Zeichenfolge zurück, die die übereinstimmende Eingabe ersetzt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersatzvorgangs das vom Konstruktor angegebene Regex.Regex(String, RegexOptions, TimeSpan) Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt ist, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Konstruktoraufruf oder in den Eigenschaften der Regex Anwendungsdomäne definiert ist oder wenn der Timeoutwert Regex.InfiniteMatchTimeoutlautet, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Methode verwenden, um zu ermitteln, ob die Object.ReferenceEquals Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Siehe auch

Gilt für:

Replace(String, String, MatchEvaluator, RegexOptions)

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

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

evaluator
MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.

options
RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input, pattern oder evaluator ist null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die einzelnen Wörter aus einer Zeichenfolge zu extrahieren und dann eine MatchEvaluator Stellvertretung zum Aufrufen einer Methode WordScramble mit dem Namen "Scramble" der einzelnen Buchstaben im Wort zu verwenden. Dazu erstellt die WordScramble Methode ein Array, das die Zeichen in der Übereinstimmung enthält. Außerdem wird ein paralleles Array erstellt, das mit zufälligen Gleitkommazahlen aufgefüllt wird. Die Arrays werden durch Aufrufen der Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Methode sortiert, und das sortierte Array wird als Argument für einen String Klassenkonstruktor bereitgestellt. Diese neu erstellte Zeichenfolge wird dann von der WordScramble Methode zurückgegeben. Das reguläre Ausdrucksmuster entspricht einem oder mehreren Wortzeichen; das reguläre Ausdrucksmodul fügt dem Übereinstimmungszeichen \w+ weiterhin Zeichen hinzu, bis es auf ein Nicht-Wort-Zeichen, z. B. ein Leerzeichen, auftritt. Der Aufruf der Replace(String, String, MatchEvaluator, RegexOptions) Methode enthält die RegexOptions.IgnorePatternWhitespace Option, damit der Kommentar im regulären Ausdrucksmuster \w+ # Matches all the characters in a word. vom regulären Ausdrucksmodul ignoriert wird.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                      RegexOptions.IgnorePatternWhitespace))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Hinweise

Die Regex.Replace(String, String, MatchEvaluator, RegexOptions) Methode ist nützlich, um einen regulären Ausdruck zu ersetzen, wenn eine der folgenden Bedingungen wahr ist:

  • Die Ersatzzeichenfolge kann nicht leicht durch ein reguläres Ausdrucksersetzungsmuster angegeben werden.

  • Die Ersatzzeichenfolge führt zu einer Verarbeitung, die auf der übereinstimmenden Zeichenfolge durchgeführt wurde.

  • Die Ersatzzeichenfolge führt aus der bedingten Verarbeitung.

Die Methode entspricht dem Aufrufen der Regex.Matches(String, String, RegexOptions) Methode und dem Übergeben jedes Match Objekts in der zurückgegebenen MatchCollection Auflistung an den evaluator Stellvertretung.

Der pattern Parameter besteht aus regulären Ausdrucksspracheelementen, die die Zeichenfolge symbolisch beschreiben, die übereinstimmen. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Quick Reference.

Der evaluator Parameter ist der Stellvertretung für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um dem MatchEvaluator Stellvertretung zu entsprechen.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Ihre benutzerdefinierte Methode gibt eine Zeichenfolge zurück, die die übereinstimmende Eingabe ersetzt.

Wenn Sie den options Parameter angebenRightToLeft, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und wird nach links verschoben. Andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und wird nach rechts verschoben.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersatzvorgangs das für die Anwendungsdomäne angegebene Timeoutintervall überschreitet, in dem die Methode aufgerufen wird. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert Regex.InfiniteMatchTimeoutangegeben ist, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Methode verwenden, um zu ermitteln, ob die Object.ReferenceEquals Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Siehe auch

Gilt für:

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

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

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions, matchTimeout As TimeSpan) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

evaluator
MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.

options
RegexOptions

Eine bitweise Kombination von Enumerationswerten, die Optionen für Vergleiche angeben.

matchTimeout
TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input, pattern oder evaluator ist null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.

- oder - matchTimeout ist negativ, null oder größer als ca. 24 Tage.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die einzelnen Wörter aus einer Zeichenfolge zu extrahieren und dann eine MatchEvaluator Stellvertretung zum Aufrufen einer Methode WordScramble mit dem Namen "Scramble" der einzelnen Buchstaben im Wort zu verwenden. Dazu erstellt die WordScramble Methode ein Array, das die Zeichen in der Übereinstimmung enthält. Außerdem wird ein paralleles Array erstellt, das mit zufälligen Gleitkommazahlen aufgefüllt wird. Die Arrays werden durch Aufrufen der Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Methode sortiert, und das sortierte Array wird als Argument für einen String Klassenkonstruktor bereitgestellt. Diese neu erstellte Zeichenfolge wird dann von der WordScramble Methode zurückgegeben. Das reguläre Ausdrucksmuster entspricht einem oder mehreren Wortzeichen; das reguläre Ausdrucksmodul fügt dem Übereinstimmungszeichen \w+ weiterhin Zeichen hinzu, bis es auf ein Nicht-Wort-Zeichen, z. B. ein Leerzeichen, auftritt. Der Aufruf der Replace(String, String, MatchEvaluator, RegexOptions) Methode enthält die RegexOptions.IgnorePatternWhitespace Option, damit der Kommentar im regulären Ausdrucksmuster \w+ # Matches all the characters in a word. vom regulären Ausdrucksmodul ignoriert wird.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      try {
         Console.WriteLine("Scrambled words:");
         Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)));      
      }
      catch (RegexMatchTimeoutException) {
         Console.WriteLine("Word Scramble operation timed out.");
         Console.WriteLine("Returned words:");
      }
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Try
         Console.WriteLine("Scrambled words:")
         Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)))      
      Catch e As RegexMatchTimeoutException
         Console.WriteLine("Word Scramble operation timed out.")
         Console.WriteLine("Returned words:")
      End Try   
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Hinweise

Die Regex.Replace(String, String, MatchEvaluator, RegexOptions) Methode ist nützlich, um einen regulären Ausdruck zu ersetzen, wenn eine der folgenden Bedingungen wahr ist:

  • Wenn die Ersatzzeichenfolge nicht leicht durch ein reguläres Ausdrucksersetzungsmuster angegeben werden kann.

  • Wenn die Ersatzzeichenfolge aus einer Verarbeitung führt, die auf der übereinstimmenden Zeichenfolge ausgeführt wird.

  • Wenn die Ersatzzeichenfolge aus der bedingten Verarbeitung resultiert.

Die Methode entspricht dem Aufrufen der Regex.Matches(String, String, RegexOptions) Methode und dem Übergeben jedes Match Objekts in der zurückgegebenen MatchCollection Auflistung an den evaluator Stellvertretung.

Der pattern Parameter besteht aus regulären Ausdrucksspracheelementen, die die Zeichenfolge symbolisch beschreiben, die übereinstimmen. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Quick Reference.

Der evaluator Parameter ist der Stellvertretung für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um dem MatchEvaluator Stellvertretung zu entsprechen.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Ihre benutzerdefinierte Methode gibt eine Zeichenfolge zurück, die die übereinstimmende Eingabe ersetzt.

Wenn Sie den options Parameter angebenRightToLeft, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und wird nach links verschoben. Andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und wird nach rechts verschoben.

Der matchTimeout Parameter gibt an, wie lange eine Musterabgleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor es ausgeht. Durch das Festlegen eines Timeoutintervalls wird verhindert, dass reguläre Ausdrücke, die auf übermäßige Backtracking basieren, angezeigt werden, um die Antwort zu beenden, wenn sie Eingaben verarbeiten, die in der Nähe übereinstimmungen enthalten. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke und Backtracking. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standard-Timeout-Wert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Methode verwenden, um zu ermitteln, ob die Object.ReferenceEquals Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen entsprechenden Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie angeben InfiniteMatchTimeout, bietet das reguläre Ausdrucksmodul etwas bessere Leistung. Allerdings sollten Sie Timeouts nur unter den folgenden Bedingungen deaktivieren:

  • Wenn die Eingabe, die von einem regulären Ausdruck verarbeitet wird, aus einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.

  • Wenn das reguläre Ausdrucksmuster gründlich getestet wurde, um sicherzustellen, dass es übereinstimmungen, nicht übereinstimmende und nahe Übereinstimmungen effizient behandelt.

  • Wenn das reguläre Ausdrucksmuster keine Sprachelemente enthält, die bekannt sind, dass eine übermäßige Rückverfolgung beim Verarbeiten einer nahen Übereinstimmung verursacht wird.

Siehe auch

Gilt für:

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.

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count, int startat);
public string Replace (string input, string replacement, int count, int startat);
member this.Replace : string * string * int * int -> string
Public Function Replace (input As String, replacement As String, count As Integer, startat As Integer) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

replacement
String

Die Ersatzzeichenfolge.

count
Int32

Die maximale Anzahl der Ersetzungen.

startat
Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn keine Entsprechung für das reguläre Ausdrucksmuster in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

input oder replacement ist null.

startat ist kleiner als 0 (null) oder größer als die Länge von input.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel werden alle Leerzeichen, aber die erste Zeile einer Zeichenfolge doppelt leer. Es definiert ein reguläres Ausdrucksmuster, ^.*$das einer Textzeile entspricht, ruft die Match(String) Methode auf, um der ersten Zeile der Zeichenfolge zu entsprechen, und verwendet die Match.Index und Match.Count die Eigenschaften, um die Anfangsposition der zweiten Zeile zu bestimmen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Instantiating a New Type\n" +
                     "Generally, there are two ways that an\n" + 
                     "instance of a class or structure can\n" +
                     "be instantiated. ";
      string pattern = "^.*$";
      string replacement = "\n$&";
      Regex rgx = new Regex(pattern, RegexOptions.Multiline);
      string result = String.Empty; 
      
      Match match = rgx.Match(input);
      // Double space all but the first line.
      if (match.Success) 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1);

      Console.WriteLine(result);                     
   }
}
// The example displays the following output:
//       Instantiating a New Type
//       
//       Generally, there are two ways that an
//       
//       instance of a class or structure can
//       
//       be instntiated.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Instantiating a New Type" + vbCrLf + _
                            "Generally, there are two ways that an" + vbCrLf + _
                            "instance of a class or structure can" + vbCrLf + _
                            "be instantiated. "
      Dim pattern As String = "^.*$"
      Dim replacement As String = vbCrLf + "$&"
      Dim rgx As New Regex(pattern, RegexOptions.Multiline)
      Dim result As String = String.Empty 
      
      Dim match As Match = rgx.Match(input)
      ' Double space all but the first line.
      If match.Success Then 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1)
      End If
      Console.WriteLine(result)                      
   End Sub
End Module
' The example displays the following output:
'       Instantiating a New Type
'       
'       Generally, there are two ways that an
'       
'       instance of a class or structure can
'       
'       be instntiated.

Das Muster für reguläre Ausdrücke ^.*$ wird entsprechend der folgenden Tabelle definiert:

Muster BESCHREIBUNG
^ Stimmen Sie mit dem Anfang einer Zeile überein. (Beachten Sie, dass das Regex Objekt mithilfe der RegexOptions.Multiline Option instanziiert wurde. Andernfalls würde diese Zeichenklasse nur dem Anfang der Eingabezeichenfolge entsprechen.)
.* Übereinstimmung mit keinem oder mehreren beliebigen Zeichen.
$ Stimmen Sie mit dem Ende einer Zeile überein. (Beachten Sie, dass das Regex Objekt mithilfe der RegexOptions.Multiline Option instanziiert wurde. Andernfalls würde diese Zeichenklasse nur dem Anfang der Eingabezeichenfolge entsprechen.)

Die Ersatzzeichenfolge (vbCrLf + "$&" in Visual Basic"\n$&", in C#) fügt eine neue Zeile vor der übereinstimmenen Zeichenfolge hinzu. Beachten Sie, dass \n im C#-Beispiel vom C#-Compiler als Newlinezeichen interpretiert wird. Es stellt keinen regulären Ausdruckszeichen escape dar.

Hinweise

Die Suche nach Übereinstimmungen beginnt in der input Zeichenfolge an der position, die durch den startat Parameter angegeben wird. Der reguläre Ausdruck ist das Muster, das vom Konstruktor für das aktuelle Regex Objekt definiert wird. Wenn count dies negativ ist, werden Ersetzungen am Ende der Zeichenfolge fortgesetzt. Wenn count die Anzahl der Übereinstimmungen überschritten wird, werden alle Übereinstimmungen ersetzt.

Der replacement Parameter gibt die Zeichenfolge an, die jede Übereinstimmung ersetzen inputsoll. replacement kann aus einer beliebigen Kombination aus Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die der Aufnahmegruppe entspricht, sofern vorhanden, gefolgt von der test Zeichenfolge "b". Das *-Zeichen wird nicht als Metacharacter innerhalb eines Ersatzmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Regulären Ausdrucksspracheelemente, die in einem Ersatzmuster erkannt werden. Alle anderen Regulären Ausdrucksspracheelemente, einschließlich Zeichen escapes, sind nur in regulären Ausdrucksmustern zulässig und werden nicht in Ersatzmustern erkannt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt ist, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben wird, wenn keine Übereinstimmung vorhanden input ist, können Sie mithilfe der Object.ReferenceEquals Methode ermitteln, ob die Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Siehe auch

Gilt für:

Replace(String, String, String)

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

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement);
public static string Replace (string input, string pattern, string replacement);
static member Replace : string * string * string -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

replacement
String

Die Ersatzzeichenfolge.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input, pattern oder replacement ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, \s+der einem oder mehreren Leerzeichen entspricht. Die Ersetzungszeichenfolge " " ersetzt sie durch ein einzelnes Leerzeichen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      string result = Regex.Replace(input, pattern, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim result As String = Regex.Replace(input, pattern, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

Im folgenden Beispiel wird die Replace(String, String, String) Methode verwendet, um die lokalen Computer- und Laufwerknamen in einem UNC-Pfad durch einen lokalen Dateipfad zu ersetzen. Der reguläre Ausdruck verwendet die Environment.MachineName Eigenschaft, um den Namen des lokalen Computers einzuschließen, und die Environment.GetLogicalDrives Methode, um die Namen der logischen Laufwerke einzuschließen. Um das Beispiel erfolgreich auszuführen, sollten Sie die Literalzeichenfolge "MyMachine" durch ihren lokalen Computernamen ersetzen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\(?i:" + Environment.MachineName + @")(?:\.\w+)*\\((?i:[" + driveNames + @"]))\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Das Muster für reguläre Ausdrücke wird durch den folgenden Ausdruck definiert:

"\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

Die folgende Tabelle zeigt, wie das Muster eines regulären Ausdrucks interpretiert wird.

Muster BESCHREIBUNG
\\\\ Stimmen Sie zwei aufeinander folgende Schrägstriche (\) ab. Da das umgekehrte Schrägstrichzeichen als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich escapet werden.
(?i:" + Environment.MachineName + ") Führen Sie eine Übereinstimmung zwischen Groß- und Kleinschreibung der Zeichenfolge aus, die von der Environment.MachineName Eigenschaft zurückgegeben wird.
(?:\.\w+)* Entspricht dem Punkt (.) Zeichen gefolgt von einem oder mehreren Wortzeichen. Diese Übereinstimmung kann null oder mehr Mal auftreten. Der übereinstimmene Unterausdruck wird nicht erfasst.
\\ Stimmen Sie mit einem umgekehrten Schrägstrich (\) überein.
((?i:[" + driveNames + "])) Führen Sie eine Übereinstimmung zwischen Groß- und Kleinschreibung der Zeichenklasse aus, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist der erste erfasste Subexpression.
\$ Stimmen Sie mit dem Literal-Dollarzeichen ($) überein.

Das Ersatzmuster $1 ersetzt die gesamte Übereinstimmung durch den ersten erfassten Subexpression. Das heißt, er ersetzt den UNC-Computer und den Laufwerksnamen durch den Laufwerkbuchstaben.

Hinweise

Die statischen Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen regulären Replace Ausdrucksmuster und aufrufen der InstanzmethodeReplace.

Der pattern Parameter besteht aus regulären Ausdrucksspracheelementen, die die zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Kurzübersicht. Die Suche nach Übereinstimmungen beginnt am Anfang der input Zeichenfolge.

Der replacement Parameter gibt die Zeichenfolge an, die jede Übereinstimmung ersetzen inputsoll. replacement kann aus einer beliebigen Kombination aus Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die der Aufnahmegruppe entspricht, sofern vorhanden, gefolgt von der test Zeichenfolge "b". Das *-Zeichen wird nicht als Metacharacter innerhalb eines Ersatzmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Regulären Ausdrucksspracheelemente, die in einem Ersatzmuster erkannt werden. Alle anderen Regulären Ausdrucksspracheelemente, einschließlich Zeichen escapes, sind nur in regulären Ausdrucksmustern zulässig und werden nicht in Ersatzmustern erkannt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgangs das für die Anwendungsdomäne angegebene Timeoutintervall überschreitet, in dem die Methode aufgerufen wird. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben wird, wenn keine Übereinstimmung vorhanden input ist, können Sie mithilfe der Object.ReferenceEquals Methode ermitteln, ob die Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Diese Methode timeouts nach einem Intervall, das dem Standardmäßigen Timeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der die Methode verhindert, dass die Zeitüberschreitung erfolgt. Die empfohlene statische Methode zum Ersetzen einer Mustervergleichung ist Replace(String, String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Siehe auch

Gilt für:

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.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.

evaluator
MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.

input, pattern oder evaluator ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die einzelnen Wörter aus einer Zeichenfolge zu extrahieren, und anschließend wird eine MatchEvaluator Stellvertretung zum Aufrufen einer Methode verwendet WordScramble , die die einzelnen Buchstaben im Wort scramble. Dazu erstellt die WordScramble Methode ein Array, das die Zeichen in der Übereinstimmung enthält. Außerdem wird ein paralleles Array erstellt, das mit zufälligen Gleitkommazahlen aufgefüllt wird. Die Arrays werden durch Aufrufen der Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Methode sortiert, und das sortierte Array wird als Argument für einen String Klassenkonstruktor bereitgestellt. Diese neu erstellte Zeichenfolge wird dann von der WordScramble Methode zurückgegeben. Das Muster für reguläre Ausdrücke \w+ entspricht einem oder mehreren Wortzeichen. Das Reguläre Ausdrucksmodul fügt der Übereinstimmung weiterhin Zeichen hinzu, bis es auf ein Nicht-Wort-Zeichen, z. B. ein Leerzeichen, trifft.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+"                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Hinweise

Die Regex.Replace(String, String, MatchEvaluator) Methode ist nützlich, um eine Übereinstimmung mit regulären Ausdrücken zu ersetzen, wenn eine der folgenden Bedingungen erfüllt ist:

  • Die Ersetzungszeichenfolge kann nicht ohne weiteres durch ein Ersatzmuster für reguläre Ausdrücke angegeben werden.

  • Die Ersetzungszeichenfolge führt zu einer Verarbeitung, die auf der übereinstimmenden Zeichenfolge erfolgt ist.

  • Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

Die Methode entspricht dem Aufrufen der Regex.Matches(String, String) Methode und übergeben jedes Match Objekt in der zurückgegebenen MatchCollection Auflistung an den evaluator Delegaten.

Der pattern Parameter besteht aus regulären Ausdrucksspracheelementen, die die zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Kurzübersicht.

Der evaluator Parameter ist die Stellvertretung für eine benutzerdefinierte Methode, die Sie definieren und jede Übereinstimmung untersuchen. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um der MatchEvaluator Stellvertretung zu entsprechen.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Ihre benutzerdefinierte Methode gibt eine Zeichenfolge zurück, die die übereinstimmende Eingabe ersetzt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgangs das für die Anwendungsdomäne angegebene Timeoutintervall überschreitet, in dem die Methode aufgerufen wird. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben wird, wenn keine Übereinstimmung vorhanden input ist, können Sie mithilfe der Object.ReferenceEquals Methode ermitteln, ob die Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Diese Methode timeouts nach einem Intervall, das dem Standardmäßigen Timeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der die Methode verhindert, dass die Zeitüberschreitung erfolgt. Die empfohlene statische Methode zum Auswerten und Ersetzen einer Mustervergleichung ist Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Siehe auch

Gilt für:

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.

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count);
public string Replace (string input, string replacement, int count);
member this.Replace : string * string * int -> string
Public Function Replace (input As String, replacement As String, count As Integer) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

replacement
String

Die Ersatzzeichenfolge.

count
Int32

Die maximale Anzahl der Ersetzungen.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn keine Entsprechung für das reguläre Ausdrucksmuster in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

input oder replacement ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel werden die ersten fünf Vorkommen duplizierter Zeichen durch ein einzelnes Zeichen ersetzt. Das Muster für reguläre Ausdrücke (\w)\1 entspricht aufeinander folgenden Vorkommen eines einzelnen Zeichens und weist der ersten Aufnahmegruppe das erste Vorkommen zu. Das Ersatzmuster $1 ersetzt die gesamte Übereinstimmung durch die erste erfasste Gruppe.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string str = "aabccdeefgghiijkklmm";
      string pattern = "(\\w)\\1"; 
      string replacement = "$1"; 
      Regex rgx = new Regex(pattern);

      string result = rgx.Replace(str, replacement, 5);
      Console.WriteLine("Original String:    '{0}'", str);
      Console.WriteLine("Replacement String: '{0}'", result); 
   }
}
// The example displays the following output:
//       Original String:    'aabccdeefgghiijkklmm'
//       Replacement String: 'abcdefghijkklmm'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim str As String = "aabccdeefgghiijkklmm"
      Dim pattern As String = "(\w)\1" 
      Dim replacement As String = "$1" 
      Dim rgx As New Regex(pattern)

      Dim result As String = rgx.Replace(str, replacement, 5)
      Console.WriteLine("Original String:    '{0}'", str)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    'aabccdeefgghiijkklmm'
'       Replacement String: 'abcdefghijkklmm'

Hinweise

Die Suche nach Übereinstimmungen beginnt am Anfang der input Zeichenfolge. Der reguläre Ausdruck ist das Muster, das vom Konstruktor für das aktuelle Regex Objekt definiert wird. Wenn count dies negativ ist, werden Ersetzungen am Ende der Zeichenfolge fortgesetzt. Wenn count die Anzahl der Übereinstimmungen überschritten wird, werden alle Übereinstimmungen ersetzt.

Der replacement Parameter gibt die Zeichenfolge an, die die ersten count Übereinstimmungen in inputersetzen soll. replacement kann aus einer beliebigen Kombination aus Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die der Aufnahmegruppe entspricht, sofern vorhanden, gefolgt von der test Zeichenfolge "b". Das *-Zeichen wird nicht als Metacharacter innerhalb eines Ersatzmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Regulären Ausdrucksspracheelemente, die in einem Ersatzmuster erkannt werden. Alle anderen Regulären Ausdrucksspracheelemente, einschließlich Zeichen escapes, sind nur in regulären Ausdrucksmustern zulässig und werden nicht in Ersatzmustern erkannt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt ist, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben wird, wenn keine Übereinstimmung vorhanden input ist, können Sie mithilfe der Object.ReferenceEquals Methode ermitteln, ob die Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Siehe auch

Gilt für:

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.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string
Public Function Replace (input As String, evaluator As MatchEvaluator) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

evaluator
MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn keine Entsprechung für das reguläre Ausdrucksmuster in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

input oder evaluator ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Das folgende Codebeispiel zeigt eine ursprüngliche Zeichenfolge an, entspricht jedem Wort in der ursprünglichen Zeichenfolge, konvertiert das erste Zeichen jeder Übereinstimmung in Großbuchstaben und zeigt dann die konvertierte Zeichenfolge an.

using System;
using System.Text.RegularExpressions;

class RegExSample
{
    static string CapText(Match m)
    {
        // Get the matched string.
        string x = m.ToString();
        // If the first char is lower case...
        if (char.IsLower(x[0]))
        {
            // Capitalize it.
            return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
        }
        return x;
    }

    static void Main()
    {
        string text = "four score and seven years ago";

        Console.WriteLine($"text=[{text}]");

        Regex rx = new Regex(@"\w+");

        string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));

        Console.WriteLine($"result=[{result}]");
    }
}
// The example displays the following output:
//       text=[four score and seven years ago]
//       result=[Four Score And Seven Years Ago]
Imports System.Text.RegularExpressions

Module RegExSample
    Function CapText(ByVal m As Match) As String
        ' Get the matched string.
        Dim x As String = m.ToString()
        ' If the first char is lower case...
        If Char.IsLower(x.Chars(0)) Then
            ' Capitalize it.
            Return Char.ToUpper(x.Chars(0)) & x.Substring(1, x.Length - 1)
        End If
        Return x
    End Function

    Sub Main()
        Dim text As String = "four score and seven years ago"

        Console.WriteLine($"text=[{text}]")

        Dim rx As New Regex("\w+")

        Dim result As String = rx.Replace(text, AddressOf RegExSample.CapText)

        Console.WriteLine($"result=[{result}]")
    End Sub
End Module
' The example displays the following output:
'       text=[four score and seven years ago]
'       result=[Four Score And Seven Years Ago]

Hinweise

Die Regex.Replace(String, MatchEvaluator) Methode ist nützlich, um einen regulären Ausdruck zu ersetzen, wenn eine der folgenden Bedingungen wahr ist:

  • Die Ersatzzeichenfolge kann nicht leicht durch ein reguläres Ausdrucksersetzungsmuster angegeben werden.

  • Die Ersatzzeichenfolge führt zu einer Verarbeitung, die auf der übereinstimmenden Zeichenfolge durchgeführt wurde.

  • Die Ersatzzeichenfolge führt aus der bedingten Verarbeitung.

Die Methode entspricht dem Aufrufen der Regex.Matches(String) Methode und dem Übergeben jedes Match Objekts in der zurückgegebenen MatchCollection Auflistung an den evaluator Stellvertretung.

Der reguläre Ausdruck ist das Muster, das vom Konstruktor für das aktuelle Regex Objekt definiert wird.

Der evaluator Parameter ist der Stellvertretung für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um dem MatchEvaluator Stellvertretung zu entsprechen.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Ihre benutzerdefinierte Methode gibt eine Zeichenfolge zurück, die die übereinstimmende Eingabe ersetzt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt ist, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben wird, wenn keine Übereinstimmung vorhanden input ist, können Sie mithilfe der Object.ReferenceEquals Methode ermitteln, ob die Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Siehe auch

Gilt für:

Replace(String, String)

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

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement);
public string Replace (string input, string replacement);
member this.Replace : string * string -> string
Public Function Replace (input As String, replacement As String) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

replacement
String

Die Ersatzzeichenfolge.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn keine Entsprechung für das reguläre Ausdrucksmuster in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

input oder replacement ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck definiert, \s+der einem oder mehreren Leerzeichen entspricht. Die Ersatzzeichenfolge " " ersetzt sie durch ein einzelnes Leerzeichen.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

Im folgenden Beispiel wird ein regulärer Ausdruck und ein Ersatzmuster definiert, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?``$2das entweder ein führendes oder ein nachgestelltes Währungssymbol aus einem numerischen Wert entfernt.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern =  @"(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?";
      string input = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17";
      string replacement = "$2";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);

      Console.WriteLine("Original String:    '{0}'", input);
      Console.WriteLine("Replacement String: '{0}'", result);                             
   }
}
// The example displays the following output:
//       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
//       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String =  "(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?"
      Dim input As String = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17"
      Dim replacement As String = "$2"
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)

      Console.WriteLine("Original String:    '{0}'", input)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
'       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Muster BESCHREIBUNG
\p{Sc} Entspricht einem Währungssymbol. {Sc} Gibt jedes Zeichen an, das mitglied des Unicode-Symbols, der Währungskategorie ist.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.
(\p{Sc}\s?)? Entspricht null oder einem Vorkommen der Kombination eines Währungssymbols gefolgt von Null oder einem Leerzeichen. Dies ist die erste Erfassungsgruppe.
\d+ Entsprechung für mindestens eine Dezimalstelle finden.
\.? Entspricht null oder einem Vorkommen eines Zeitraums (wird als Dezimaltrennzeichen verwendet).
((?<=\.)\d+)? Wenn ein Zeitraum das vorherige Zeichen ist, stimmen Sie mit einer oder mehreren Dezimalstellen überein. Dieses Muster kann entweder null oder einmal übereinstimmen.
(\d+\.?((?<=\.)\d+)?) Entspricht dem Muster einer oder mehreren Dezimalstellen, gefolgt von einem optionalen Zeitraum und zusätzlichen Dezimalstellen. Dies ist die zweite Erfassungsgruppe. Der Aufruf der Replace(String, String) Methode ersetzt die gesamte Übereinstimmung durch den Wert dieser erfassten Gruppe.
(?(1)|\s?\p{Sc})? Wenn die erste erfasste Gruppe vorhanden ist, entspricht eine leere Zeichenfolge. Andernfalls entsprechen Null oder ein Leerzeichen, gefolgt von einem Währungssymbol.

Hinweise

Die Suche nach Übereinstimmungen beginnt am Anfang der input Zeichenfolge. Der reguläre Ausdruck ist das Muster, das vom Konstruktor für das aktuelle Regex Objekt definiert wird.

Der replacement Parameter gibt die Zeichenfolge an, die jede Übereinstimmung ersetzen inputsoll. replacement kann aus einer beliebigen Kombination von Literaltext und Ersatz bestehen. Das Ersatzmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die der Aufnahmegruppe entspricht, sofern vorhanden, gefolgt von der test Zeichenfolge "b". Das *-Zeichen wird nicht als Metacharacter innerhalb eines Ersatzmusters erkannt.

Hinweis

Ersetzungen sind die einzigen regulären Ausdrucksspracheelemente, die in einem Ersatzmuster erkannt werden. Alle anderen Regulären Ausdrucksspracheelemente, einschließlich Zeichenauslöser, sind nur in regulären Ausdrucksmustern zulässig und werden nicht in Ersatzmustern erkannt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersatzvorgangs das vom Konstruktor angegebene Regex.Regex(String, RegexOptions, TimeSpan) Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt ist, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Konstruktoraufruf oder in den Eigenschaften der Regex Anwendungsdomäne definiert ist oder wenn der Timeoutwert Regex.InfiniteMatchTimeoutlautet, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Methode verwenden, um zu ermitteln, ob die Object.ReferenceEquals Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Siehe auch

Gilt für:

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.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string
Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

evaluator
MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.

count
Int32

Die maximale Anzahl der Ersetzungen.

Gibt zurück

String

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen. Wenn keine Entsprechung für das reguläre Ausdrucksmuster in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

input oder evaluator ist null.

Es ist ein Timeout aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die Hälfte der Wörter in einer Liste absichtlich falsch geschrieben zu haben. Es verwendet den regulären Ausdruck \w*(ie|ei)\w* , um Wörter abzugleichen, die die Zeichen "ie" oder "ei" enthalten. Die erste Hälfte der übereinstimmenden Wörter wird an die ReverseLetter Methode übergeben, die wiederum die Replace(String, String, String, RegexOptions) Methode verwendet, um "i" und "e" in der übereinstimmenden Zeichenfolge umzukehren. Die übrigen Wörter bleiben unverändert.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "deceive relieve achieve belief fierce receive";
      string pattern = @"\w*(ie|ei)\w*";
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
      Console.WriteLine("Original string: " + input);
      
      string result = rgx.Replace(input, new MatchEvaluator(Example.ReverseLetter), 
                                  input.Split(' ').Length / 2);
      Console.WriteLine("Returned string: " + result);
   }

   static string ReverseLetter(Match match)
   {
      return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase);            
   }
}
// The example displays the following output:
//    Original string: deceive relieve achieve belief fierce receive
//    Returned string: decieve releive acheive belief fierce receive
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "deceive relieve achieve belief fierce receive"
      Dim pattern As String = "\w*(ie|ei)\w*"
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
      Console.WriteLine("Original string: " + input)
      
      Dim result As String = rgx.Replace(input, AddressOf ReverseLetter, 
                                           input.Split(" "c).Length \ 2)
      Console.WriteLine("Returned string: " + result)
   End Sub

   Public Function ReverseLetter(match As Match) As String
      Return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase)            
   End Function
End Module
' The example displays the following output:
'    Original string: deceive relieve achieve belief fierce receive
'    Returned string: decieve releive acheive belief fierce receive

Der reguläre Ausdruck \w*(ie|ei)\w* wird entsprechend der Darstellung in der folgenden Tabelle definiert:

Muster BESCHREIBUNG
\w* Übereinstimmung mit keinem oder mehreren Wortzeichen.
(ie|ei) Stimmen Sie entweder mit "ie" oder "ei" überein.
\w* Übereinstimmung mit keinem oder mehreren Wortzeichen.

Das Muster für reguläre Ausdrücke ([ie])([ie]) in der ReverseLetter Methode stimmt mit dem ersten "i" oder "e" im Diphthong "ie" oder "ei" überein und weist den Buchstaben der ersten Aufnahmegruppe zu. Sie stimmt mit dem zweiten "i" oder "e" überein und weist dem zweiten Aufnahmegruppen den Buchstaben zu. Die beiden Zeichen werden dann durch Aufrufen der Replace(String, String, String) Methode mit dem Ersatzmuster $2$1umgekehrt.

Hinweise

Die Regex.Replace(String, MatchEvaluator, Int32) Methode ist nützlich, um eine Übereinstimmung mit regulären Ausdrücken zu ersetzen, wenn eine der folgenden Bedingungen erfüllt ist:

  • Die Ersetzungszeichenfolge kann nicht ohne weiteres durch ein Ersatzmuster für reguläre Ausdrücke angegeben werden.

  • Die Ersetzungszeichenfolge führt zu einer Verarbeitung, die auf der übereinstimmenden Zeichenfolge erfolgt ist.

  • Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

Die Methode entspricht dem Aufrufen der Regex.Matches(String) Methode und dem Übergeben der ersten countMatch Objekte in der zurückgegebenen MatchCollection Auflistung an den evaluator Delegaten.

Der reguläre Ausdruck ist das Muster, das vom Konstruktor für das aktuelle Regex Objekt definiert wird.

Der evaluator Parameter ist die Stellvertretung für eine benutzerdefinierte Methode, die Sie definieren und jede Übereinstimmung untersuchen. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um der MatchEvaluator Stellvertretung zu entsprechen.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

Ihre benutzerdefinierte Methode gibt eine Zeichenfolge zurück, die die übereinstimmende Eingabe ersetzt.

Die RegexMatchTimeoutException Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgangs das vom Regex.Regex(String, RegexOptions, TimeSpan) Konstruktor angegebene Timeoutintervall überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Timeoutintervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeoutwert überschreitet, der für die Anwendungsdomäne festgelegt ist, in der das Regex Objekt erstellt wird. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Timeoutwert lautet Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgegeben wird, wenn keine Übereinstimmung vorhanden input ist, können Sie mithilfe der Object.ReferenceEquals Methode ermitteln, ob die Methode Ersatz für die Eingabezeichenfolge vorgenommen hat.

Siehe auch

Gilt für: