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, MatchEvaluator, RegexOptions, TimeSpan)

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

Replace(String, String, String, 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, 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, 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, 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, String)

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

Replace(String, String, Int32)

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

Replace(String, 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, 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 anschließend wird ein MatchEvaluator Delegat verwendet, um eine Methode namens WordScramble aufzurufen, die die einzelnen Buchstaben im Wort scramblet. Hierzu 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+ stimmt mit einem oder mehreren Wortzeichen überein. Die Engine für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis ein Nichtwortzeichen wie ein Leerzeichen gefunden wird. Der Aufruf der Replace(String, String, MatchEvaluator, RegexOptions) -Methode enthält die RegexOptions.IgnorePatternWhitespace -Option, sodass der Kommentar im Muster für reguläre Ausdrücke \w+ # Matches all the characters in a word. von der Engine für reguläre Ausdrücke 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 eine Übereinstimmung mit regulären Ausdrücken zu ersetzen, wenn eine der folgenden Bedingungen zutrifft:

  • Wenn die Ersetzungszeichenfolge nicht ohne Weiteres durch ein Reguläres Ausdrucks-Ersetzungsmuster angegeben werden kann.

  • Wenn die Ersetzungszeichenfolge aus einer Verarbeitung resultiert, die für die übereinstimmende Zeichenfolge ausgeführt wird.

  • Wenn die Ersetzungszeichenfolge 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 Auflistung an den MatchCollection evaluator Delegaten.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die abzugleichende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzübersicht.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung überprüft. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um mit dem Delegaten übereinstimmen zu MatchEvaluator können.

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 RightToLeft für den options -Parameter angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und verschiebt sich nach links. Andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und verschiebt sich nach rechts.

Der matchTimeout -Parameter gibt an, wie lange eine Musterabgleichsmethode versuchen soll, eine Übereinstimmung zu finden, bevor ein Zeitauslauf erfolgt. Durch das Festlegen eines Time out-Intervalls wird verhindert, dass reguläre Ausdrücke, die von übermäßiger Rückverfolgung abhängig sind, so angezeigt werden, dass sie nicht mehr reagieren, wenn sie Eingaben verarbeiten, die nahezu Übereinstimmungen enthalten. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke und Rückverfolgung. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standardtime out-Wert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Da die Methode input unverändert zurückgibt, wenn keine Übereinstimmung vorliegt, können Sie mithilfe der Object.ReferenceEquals -Methode bestimmen, ob die Methode die Eingabezeichenfolge ersetzt hat.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Time outs deaktivieren, indem Sie InfiniteMatchTimeout angeben, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Time outs sollten jedoch nur unter den folgenden Bedingungen deaktiviert werden: – Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dadurch wird Text ausgeschlossen, der von Benutzern dynamisch eingegeben wurde.

– Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass übereinstimmungen, nicht übereinstimmende und nahezu übereinstimmende Übereinstimmungen effizient verarbeitet werden.

– Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen eine übermäßige Rückverfolgung verursachen, wenn eine Nahezu-Übereinstimmung verarbeitet wird.

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 Replace(String, String, String, RegexOptions, TimeSpan) -Methode verwendet, um die Namen des lokalen Computers und laufwerks 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. Bei allen Zeichenfolgenvergleichen für reguläre Ausdrücke wird die Groß-/Kleinschreibung nicht beachtet, und bei jedem einzelnen Ersetzungsvorgang tritt ein Zeitsausbruch auf, wenn eine Übereinstimmung in 0,5 Sekunden nicht gefunden werden kann. Um das Beispiel erfolgreich auszuführen, sollten Sie die Literalzeichenfolge "MyMachine" durch den Namen Ihres lokalen Computers 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 Muster für reguläre Ausdrücke 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
\\\\ Übereinstimmung mit zwei aufeinander folgenden umgekehrten Schrägstrichen \ () Da der umgekehrte Schrägstrich als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich mit Escapezeichen verbunden werden.
+ Environment.MachineName + Übereinstimmung mit der Zeichenfolge, die von der -Eigenschaft zurückgegeben Environment.MachineName wird.
(?:\.\w+)* Übereinstimmung mit dem Punkt ( . ) gefolgt von einem oder mehreren Wortzeichen. Diese Übereinstimmung kann 0 (null) oder mehrmals auftreten. Der übereinstimmende Teilausdruck wird nicht erfasst.
\\ Übereinstimmung mit einem umgekehrten Schrägstrich \ ()
([" + driveNames + "]) Übereinstimmung mit der Zeichenklasse, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist der erste erfasste Teilausdruck.
\$ Übereinstimmung mit dem Literalzeichen dollar sign ( $ ) .

Das Ersetzungsmuster $1 ersetzt die gesamte Übereinstimmung durch den ersten erfassten Teilausdruck. Das heißt, dass der UNC-Computer und der Laufwerksname durch den Laufwerkbuchstaben ersetzt werden.

Hinweise

Die statischen Replace Methoden entsprechen dem Erstellen eines Regex -Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Aufrufen der Instanzmethode Replace .

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die abzugleichende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzübersicht. Wenn Sie RightToLeft für den options -Parameter angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und verschiebt sich nach links. Andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und verschiebt sich nach rechts.

Der replacement -Parameter gibt die Zeichenfolge an, die jede Übereinstimmung in ersetzen input soll. replacement kann aus einer beliebigen Kombination aus Literaltext und Ersetzungenbestehen. Beispielsweise fügt das Ersetzungsmuster a*${test}b die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die von der Erfassungsgruppe abgegleicht test wird, sofern vorhanden, gefolgt von der Zeichenfolge "b". Das *-Zeichen wird nicht als Metazeichen innerhalb eines Ersetzungsmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungsmuster erkannt werden. Alle anderen Sprachelemente für reguläre Ausdrücke, einschließlich Zeichen-Escapezeichen,sind nur in Mustern für reguläre Ausdrücke zulässig und werden in Ersetzungsmustern nicht erkannt.

Der matchTimeout -Parameter gibt an, wie lange eine Musterabgleichsmethode versuchen soll, eine Übereinstimmung zu finden, bevor ein Zeitauslauf erfolgt. Das Festlegen eines Time out-Intervalls verhindert, dass reguläre Ausdrücke, die auf übermäßiger Rückverfolgung basieren, nicht mehr reagieren, wenn sie Eingaben verarbeiten, die nahezu Übereinstimmungen enthalten. Weitere Informationen finden Sie unter Bewährte Methoden für reguläre Ausdrücke und Rückverfolgung. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standardtime out-Wert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Da die Methode input unverändert zurückgibt, wenn keine Übereinstimmung vorliegt, können Sie mithilfe der Object.ReferenceEquals -Methode bestimmen, ob die Methode die Eingabezeichenfolge ersetzt hat.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Time outs deaktivieren, indem Sie InfiniteMatchTimeout angeben, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Time outs sollten jedoch nur unter den folgenden Bedingungen deaktiviert werden: – Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dadurch wird Text ausgeschlossen, der von Benutzern dynamisch eingegeben wurde.

– Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass übereinstimmungen, nicht übereinstimmende und nahezu übereinstimmende Übereinstimmungen effizient verarbeitet werden.

– Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen eine übermäßige Rückverfolgung verursachen, wenn eine Nahezu-Übereinstimmung verarbeitet 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 eine Übereinstimmung mit regulären Ausdrücken zu ersetzen, wenn eine der folgenden Bedingungen zutrifft:

  • Die Ersetzungszeichenfolge kann nicht ohne Weiteres durch ein Reguläres Ausdrucks-Ersetzungsmuster angegeben werden.

  • Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmende Zeichenfolge durchgeführt wurde.

  • Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

Die -Methode entspricht dem Aufrufen der Regex.Matches(String, Int32) -Methode und dem Übergeben der ersten count Match 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 Objekt definiert Regex wird.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung überprüft. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um mit dem Delegaten übereinstimmen zu MatchEvaluator können.

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 Konstruktor angegebene Time out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Regex Objekt erstellt wird. Wenn im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne kein Time out definiert ist Regex oder der Time out-Wert ist, Regex.InfiniteMatchTimeout wird keine Ausnahme ausgelöst.

Da die Methode input unverändert zurückgibt, wenn keine Übereinstimmung vorliegt, können Sie mithilfe der Object.ReferenceEquals -Methode bestimmen, ob die Methode die Eingabezeichenfolge ersetzt 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. Anschließend wird ein Delegat verwendet, um eine Methode mit dem Namen auf aufruft, die die einzelnen Buchstaben im Wort MatchEvaluator WordScramble verschlüsselt. Hierzu erstellt die -Methode WordScramble 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 -Methode sortiert, und das sortierte Array wird als Argument für einen Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) String Klassenkonstruktor bereitgestellt. Diese neu erstellte Zeichenfolge wird dann von der -Methode WordScramble zurückgegeben. Das Muster eines regulären Ausdrucks stimmt mit einem oder mehr Wortzeichen überein. Die Engine für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis ein Nichtwortzeichen, z. B. ein Leerzeichen, vor \w+ sich geht. Der Aufruf der Replace(String, String, MatchEvaluator, RegexOptions) -Methode enthält die -Option, sodass der Kommentar im Muster für reguläre Ausdrücke von der Engine für reguläre Ausdrücke RegexOptions.IgnorePatternWhitespace \w+ # Matches all the characters in a word. 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 -Methode ist nützlich, um eine Übereinstimmung mit einem regulären Ausdruck in zu ersetzen, Regex.Replace(String, String, MatchEvaluator, RegexOptions) wenn eine der folgenden Bedingungen zutrifft:

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

  • Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmende Zeichenfolge durchgeführt wird.

  • Die Ersetzungszeichenfolge ergibt sich 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 Auflistung an den MatchCollection evaluator Delegaten.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzreferenz.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um mit dem Delegaten übereinstimmen MatchEvaluator zu können.

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 für den -Parameter angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und wechselt nach links. Andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und verschiebt RightToLeft options sich nach rechts.

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgang das time out-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der RegexMatchTimeoutException die Methode aufgerufen wird. Wenn kein Time out in den Eigenschaften der Anwendungsdomäne definiert ist oder der Time out-Wert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgibt, wenn keine Übereinstimmung vorkommt, können Sie mithilfe der -Methode bestimmen, ob die Methode Ersatz für die input Object.ReferenceEquals Eingabezeichenfolge vorgenommen hat.

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 bis auf die erste Zeile einer Zeichenfolge alle Leerzeichen doppelt leer. Sie definiert ein Muster für reguläre Ausdrücke, ^.*$ , das einer Textzeile entspricht, die -Methode aufruft, Match(String) um der ersten Zeile der Zeichenfolge zu entsprechen, und verwendet die Match.Index -Eigenschaft und Match.Count die -Eigenschaft, 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
^ Übereinstimmung mit dem Anfang einer Zeile. (Beachten Sie, dass das Objekt mithilfe der -Option instanziiert wurde. Andernfalls würde diese Zeichenklasse nur mit dem Anfang Regex RegexOptions.Multiline der Eingabezeichenfolge übereinstimmen.)
.* Übereinstimmung mit keinem oder mehreren beliebigen Zeichen.
$ Übereinstimmung mit dem Ende einer Zeile. (Beachten Sie, dass das Objekt mithilfe der -Option instanziiert wurde. Andernfalls würde diese Zeichenklasse nur mit dem Anfang Regex RegexOptions.Multiline der Eingabezeichenfolge übereinstimmen.)

Die Ersetzungszeichenfolge ( in Visual Basic, in C#) fügt eine neue Zeile vbCrLf + "$&" vor der "\n$&" übereinstimmenden Zeichenfolge hinzu. Beachten Sie, dass im C#-Beispiel vom C#-Compiler als Neue-Zeichen interpretiert wird. Es stellt kein Escapezeichen für reguläre \n Ausdrücke dar.

Hinweise

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

Der replacement -Parameter gibt die Zeichenfolge an, die jede Übereinstimmung in ersetzen input soll. replacement kann aus einer beliebigen Kombination aus Literaltext und Ersetzungenbestehen. Beispielsweise fügt das Ersetzungsmuster a*${test}b die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die von der Erfassungsgruppe abgegleicht test wird, sofern vorhanden, gefolgt von der Zeichenfolge "b". Das *-Zeichen wird nicht als Metazeichen innerhalb eines Ersetzungsmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungsmuster erkannt werden. Alle anderen Sprachelemente für reguläre Ausdrücke, einschließlich Zeichen-Escapezeichen,sind nur in Mustern für reguläre Ausdrücke zulässig und werden in Ersetzungsmustern nicht erkannt.

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

Da die Methode input unverändert zurückgibt, wenn keine Übereinstimmung vorliegt, können Sie mithilfe der Object.ReferenceEquals -Methode bestimmen, ob die Methode die Eingabezeichenfolge ersetzt hat.

Siehe auch

Gilt für

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 Namen des lokalen Computers und laufwerks Replace(String, String, String, RegexOptions) in einem UNC-Pfad durch einen lokalen Dateipfad zu ersetzen. Der reguläre Ausdruck verwendet die -Eigenschaft, um den Namen des lokalen Computers ein- und die -Methode, um die Namen der Environment.MachineName Environment.GetLogicalDrives logischen Laufwerke ein include. Bei Zeichenfolgenvergleichen mit regulären Ausdrücken wird die Groß-/Kleinschreibung nicht beachtet. Um das Beispiel erfolgreich ausführen zu können, sollten Sie die Literalzeichenfolge "MyMachine" durch den Namen Ihres lokalen Computers 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 Muster für reguläre Ausdrücke 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
\\\\ Übereinstimmung mit zwei aufeinander folgenden schrägen Schrägstrichen ( \ ) Da der schräge Schrägstrich als Escapezeichen interpretiert wird, muss jeder schräge Schrägstrich mit einem anderen schrägen Schrägstrich escapet werden.
+ Environment.MachineName + Übereinstimmung mit der Zeichenfolge, die von der -Eigenschaft zurückgegeben Environment.MachineName wird.
(?:\.\w+)* Übereinstimmung mit dem Zeichen für den Zeitraum ( . ), gefolgt von einem oder mehr Wortzeichen. Diese Übereinstimmung kann null oder mehrmals auftreten. Der übereinstimmende Teilausdruck wird nicht erfasst.
\\ Übereinstimmung mit einem schrägen Schrägstrich \ ()
([" + driveNames + "]) Übereinstimmung mit der Zeichenklasse, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist der erste erfasste Teilausdruck.
\$ Übereinstimmung mit dem literalen Dollarzeichen ( $ )

Das $1 Ersetzungsmuster ersetzt die gesamte Übereinstimmung durch den ersten erfassten Teilausdruck. Das heißt, der UNC-Computer und der Laufwerkname werden durch den Laufwerkbuchstaben ersetzt.

Hinweise

Die statischen Methoden entsprechen dem Erstellen eines -Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Replace Regex Aufrufen der Instanzmethode Replace .

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzreferenz. Wenn Sie für den -Parameter angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und wechselt nach links. Andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und verschiebt RightToLeft options sich nach rechts.

Der replacement -Parameter gibt die Zeichenfolge an, die jede Übereinstimmung in ersetzen input soll. replacementkann aus einer beliebigen Kombination aus Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster fügt z. B. die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die mit der Erfassungsgruppe (sofern enthalten) und der Zeichenfolge a*${test}b test "b" übereinstimmen. Das Zeichen * wird nicht als Metazeichen innerhalb eines Ersetzungsmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungsmuster erkannt werden. Alle anderen Sprachelemente für reguläre Ausdrücke, einschließlich Escapezeichen, sind nur in Mustern regulärer Ausdrücke zulässig und werden in Ersetzungsmustern nicht erkannt.

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgang das time out-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der RegexMatchTimeoutException die Methode aufgerufen wird. Wenn kein Time out in den Eigenschaften der Anwendungsdomäne definiert ist oder der Time out-Wert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgibt, wenn keine Übereinstimmung vorkommt, können Sie mithilfe der -Methode bestimmen, ob die Methode Ersatz für die input Object.ReferenceEquals Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Bei dieser Methode kommt es nach einem Intervall zu einem Time out, das dem Standardzeitwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn für die Anwendungsdomäne kein Time out-Wert definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Time out erfolgt. Die empfohlene statische Methode zum Ersetzen einer Muster übereinstimmung ist Replace(String, String, String, RegexOptions, TimeSpan) , mit der Sie das Time out-Intervall 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 ein MatchEvaluator Delegat verwendet, um eine Methode namens WordScramble aufzurufen, die die einzelnen Buchstaben im Wort scramblet. Hierzu 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+ stimmt mit einem oder mehreren Wortzeichen überein. Die Engine für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis ein Nichtwortzeichen wie ein Leerzeichen gefunden 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+";                            
      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 zutrifft:

  • Die Ersetzungszeichenfolge kann nicht ohne Weiteres durch ein Reguläres Ausdrucks-Ersetzungsmuster angegeben werden.

  • Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmende Zeichenfolge durchgeführt wurde.

  • Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

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

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die abzugleichende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzübersicht.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung überprüft. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um mit dem Delegaten übereinstimmen zu MatchEvaluator können.

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 time out-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der die Methode aufgerufen wird. Wenn in den Eigenschaften der Anwendungsdomäne kein Time out definiert ist oder der Time out-Wert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst.

Da die Methode input unverändert zurückgibt, wenn keine Übereinstimmung vorliegt, können Sie mithilfe der Object.ReferenceEquals -Methode bestimmen, ob die Methode die Eingabezeichenfolge ersetzt hat.

Hinweise für Aufrufer

Diese Methode führt nach einem Intervall, das dem Standardtime out-Wert der Anwendungsdomäne, in der sie aufgerufen wird, zu einem Time out-Wert kommt. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Timeout aufgetreten ist. Die empfohlene statische Methode zum Auswerten und Ersetzen einer Muster übereinstimmung ist Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan) , mit der Sie das Time out-Intervall festlegen können.

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, der mindestens einem \s+ 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 -Methode verwendet, um die Namen des lokalen Computers und laufwerks Replace(String, String, String) in einem UNC-Pfad durch einen lokalen Dateipfad zu ersetzen. Der reguläre Ausdruck verwendet die -Eigenschaft, um den Namen des lokalen Computers ein- und die -Methode, um die Namen der Environment.MachineName Environment.GetLogicalDrives logischen Laufwerke ein include. Um das Beispiel erfolgreich ausführen zu können, sollten Sie die Literalzeichenfolge "MyMachine" durch den Namen Ihres lokalen Computers 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
\\\\ Übereinstimmung mit zwei aufeinander folgenden schrägen Schrägstrichen ( \ ) Da der schräge Schrägstrich als Escapezeichen interpretiert wird, muss jeder schräge Schrägstrich mit einem anderen schrägen Schrägstrich escapet werden.
(?i:" + Environment.MachineName + ") Führen Sie eine Übereinstimmung der Zeichenfolge, die von der -Eigenschaft zurückgegeben wird, ohne Schreibung der Groß-/Kleinschreibung Environment.MachineName aus.
(?:\.\w+)* Übereinstimmung mit dem Zeichen für den Zeitraum ( . ), gefolgt von einem oder mehr Wortzeichen. Diese Übereinstimmung kann null oder mehrmals auftreten. Der übereinstimmende Teilausdruck wird nicht erfasst.
\\ Übereinstimmung mit einem schrägen Schrägstrich \ ()
((?i:[" + driveNames + "])) Führen Sie eine Übereinstimmung der Zeichenklasse durch, bei der die Groß-/Kleinschreibung nicht beachtet wird, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist der erste erfasste Teilausdruck.
\$ Übereinstimmung mit dem literalen Dollarzeichen ( $ )

Das $1 Ersetzungsmuster ersetzt die gesamte Übereinstimmung durch den ersten erfassten Teilausdruck. Das heißt, der UNC-Computer und der Laufwerkname werden durch den Laufwerkbuchstaben ersetzt.

Hinweise

Die statischen Methoden entsprechen dem Erstellen eines -Objekts mit dem angegebenen Muster für reguläre Ausdrücke und dem Replace Regex Aufrufen der Instanzmethode Replace .

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework Reguläre Ausdrücke und Sprache für reguläre Ausdrücke – Kurzreferenz. Die Suche nach Übereinstimmungen beginnt am Anfang der input Zeichenfolge.

Der replacement -Parameter gibt die Zeichenfolge an, die jede Übereinstimmung in ersetzen input soll. replacementkann aus einer beliebigen Kombination aus Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster fügt z. B. die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die mit der Erfassungsgruppe (sofern enthalten) und der Zeichenfolge a*${test}b test "b" übereinstimmen. Das Zeichen * wird nicht als Metazeichen innerhalb eines Ersetzungsmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungsmuster erkannt werden. Alle anderen Sprachelemente für reguläre Ausdrücke, einschließlich Escapezeichen, sind nur in Mustern regulärer Ausdrücke zulässig und werden in Ersetzungsmustern nicht erkannt.

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgang das time out-Intervall überschreitet, das für die Anwendungsdomäne angegeben ist, in der RegexMatchTimeoutException die Methode aufgerufen wird. Wenn kein Time out in den Eigenschaften der Anwendungsdomäne definiert ist oder der Time out-Wert Regex.InfiniteMatchTimeout ist, wird keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgibt, wenn keine Übereinstimmung vorkommt, können Sie mithilfe der -Methode bestimmen, ob die Methode Ersatz für die input Object.ReferenceEquals Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Diese Methode führt nach einem Intervall, das dem Standardtime out-Wert der Anwendungsdomäne, in der sie aufgerufen wird, zu einem Time out-Wert kommt. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert verwendet, der verhindert, dass für die Methode ein InfiniteMatchTimeout Timeout aufgetreten ist. Die empfohlene statische Methode zum Ersetzen einer Muster übereinstimmung ist Replace(String, String, String, RegexOptions, TimeSpan) , mit der Sie das Time out-Intervall 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 doppelter Zeichen durch ein einzelnes Zeichen ersetzt. Das Muster für reguläre Ausdrücke stimmt mit aufeinander folgenden Vorkommen eines einzelnen Zeichens ab und weist das erste Vorkommen (\w)\1 der ersten Erfassungsgruppe zu. Das $1 Ersetzungsmuster 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 Objekt definiert Regex wird. Wenn count negativ ist, werden die Ersetzungen bis zum Ende der Zeichenfolge fortgesetzt. Wenn count die Anzahl der Übereinstimmungen überschreitet, werden alle Übereinstimmungen ersetzt.

Der replacement -Parameter gibt die Zeichenfolge an, die die ersten Übereinstimmungen count in ersetzen input soll. replacementkann aus einer beliebigen Kombination aus Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster fügt z. B. die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die mit der Erfassungsgruppe (sofern enthalten) und der Zeichenfolge a*${test}b test "b" übereinstimmen. Das Zeichen * wird nicht als Metazeichen innerhalb eines Ersetzungsmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungsmuster erkannt werden. Alle anderen Sprachelemente für reguläre Ausdrücke, einschließlich Escapezeichen, sind nur in Mustern regulärer Ausdrücke zulässig und werden in Ersetzungsmustern nicht erkannt.

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgang das vom Konstruktor angegebene Time RegexMatchTimeoutException out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Objekt erstellt Regex wird. Wenn kein Time out im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Time Regex out-Wert ist, wird Regex.InfiniteMatchTimeout keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgibt, wenn keine Übereinstimmung vorkommt, können Sie mithilfe der -Methode bestimmen, ob die Methode Ersatz für die input Object.ReferenceEquals 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 eine Übereinstimmung mit einem regulären Ausdruck zu ersetzen, wenn eine der folgenden Bedingungen zutrifft:

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

  • Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmende Zeichenfolge durchgeführt wird.

  • Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

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

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

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um mit dem Delegaten übereinstimmen MatchEvaluator zu können.

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 Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgang das vom Konstruktor angegebene Time RegexMatchTimeoutException out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Objekt erstellt Regex wird. Wenn kein Time out im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Time Regex out-Wert ist, wird Regex.InfiniteMatchTimeout keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgibt, wenn keine Übereinstimmung vorkommt, können Sie mithilfe der -Methode bestimmen, ob die Methode Ersatz für die input Object.ReferenceEquals 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, der mindestens einem \s+ 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 = " ";
      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 werden der reguläre Ausdruck und das Ersatzmuster definiert, das entweder ein führendes oder ein nachfolgendes Währungssymbol aus (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})? $2 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} Übereinstimmung mit einem Währungssymbol. {Sc} gibt jedes Zeichen an, das mitglied der Kategorie Unicode-Symbol, Währung ist.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.
(\p{Sc}\s?)? Übereinstimmung mit 0 (null) oder einem Vorkommen der Kombination eines Währungssymbols gefolgt von 0 (null) oder einem Leerzeichen. Dies ist die erste Erfassungsgruppe.
\d+ Entsprechung für mindestens eine Dezimalstelle finden.
\.? Übereinstimmung mit 0 (null) oder einem Vorkommen eines Punkts (wird als Dezimaltrennzeichen verwendet).
((?<=\.)\d+)? Wenn ein Punkt das vorherige Zeichen ist, müssen Sie mit einer oder mehr Dezimalstellen übereinstimmen. Dieses Muster kann entweder 0 (null) oder einmal übereinstimmen.
(\d+\.?((?<=\.)\d+)?) Übereinstimmung mit dem Muster einer oder mehrere Dezimalstellen gefolgt von einem optionalen Punkt 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, finden Sie eine Übereinstimmung mit einer leeren Zeichenfolge. Andernfalls wird eine Übereinstimmung mit 0 (null) oder einem Leerzeichen gefolgt von einem Währungssymbol angezeigt.

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 Objekt definiert Regex wird.

Der replacement -Parameter gibt die Zeichenfolge an, die jede Übereinstimmung in ersetzen input soll. replacementkann aus einer beliebigen Kombination aus Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster fügt z. B. die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die mit der Erfassungsgruppe (sofern enthalten) und der Zeichenfolge a*${test}b test "b" übereinstimmen. Das Zeichen * wird nicht als Metazeichen innerhalb eines Ersetzungsmusters erkannt.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungsmuster erkannt werden. Alle anderen Sprachelemente für reguläre Ausdrücke, einschließlich Escapezeichen, sind nur in Mustern regulärer Ausdrücke zulässig und werden in Ersetzungsmustern nicht erkannt.

Die Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungsvorgang das vom Konstruktor angegebene Time RegexMatchTimeoutException out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Objekt erstellt Regex wird. Wenn kein Time out im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist oder wenn der Time Regex out-Wert ist, wird Regex.InfiniteMatchTimeout keine Ausnahme ausgelöst.

Da die Methode unverändert zurückgibt, wenn keine Übereinstimmung vorkommt, können Sie mithilfe der -Methode bestimmen, ob die Methode Ersatz für die input Object.ReferenceEquals 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 absichtlich die Hälfte der Wörter in einer Liste falsch zu verkaufen. Er verwendet den regulären \w*(ie|ei)\w* Ausdruck, 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 -Methode verwendet, Replace(String, String, String, RegexOptions) um "i" und "e" in der übereinstimmenden Zeichenfolge umzukehren. Die verbleibenden 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) Übereinstimmung mit "ie" oder "ei".
\w* Übereinstimmung mit keinem oder mehreren Wortzeichen.

Das Muster für reguläre Ausdrücke ([ie])([ie]) in der ReverseLetter -Methode entspricht dem ersten "i" oder "e" im Diphthong "ie" oder "e" und weist den Buchstaben der ersten Erfassungsgruppe zu. Er entspricht dem zweiten "i" oder "e" und weist den Buchstaben der zweiten Erfassungsgruppe zu. Die beiden Zeichen werden dann umgekehrt, indem die Replace(String, String, String) -Methode mit dem Ersetzungsmuster aufgerufen $2$1 wird.

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 zutrifft:

  • Die Ersetzungszeichenfolge kann nicht ohne Weiteres durch ein Reguläres Ausdrucks-Ersetzungsmuster angegeben werden.

  • Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmende Zeichenfolge durchgeführt wurde.

  • Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

Die -Methode entspricht dem Aufrufen der Regex.Matches(String) -Methode und dem Übergeben der ersten count Match 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 Objekt definiert Regex wird.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung überprüft. Die benutzerdefinierte Methode muss über die folgende Signatur verfügen, um mit dem Delegaten übereinstimmen zu MatchEvaluator können.

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 Konstruktor angegebene Time out-Intervall Regex.Regex(String, RegexOptions, TimeSpan) überschreitet. Wenn Sie beim Aufrufen des Konstruktors kein Time out-Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Time out-Wert überschreitet, der für die Anwendungsdomäne eingerichtet wurde, in der das Regex Objekt erstellt wird. Wenn im Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne kein Time out definiert ist Regex oder der Time out-Wert ist, Regex.InfiniteMatchTimeout wird keine Ausnahme ausgelöst.

Da die Methode input unverändert zurückgibt, wenn keine Übereinstimmung vorliegt, können Sie mithilfe der Object.ReferenceEquals -Methode bestimmen, ob die Methode die Eingabezeichenfolge ersetzt hat.

Siehe auch

Gilt für