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

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

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

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

Replace(String, MatchEvaluator, Int32)

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

Replace(String, String, MatchEvaluator)

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

Replace(String, String, Int32)

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

Replace(String, String)

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

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

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 einem regulären Ausdruck zu ersetzen, wenn eine der folgenden Bedingungen erfüllt ist:

  • Die Ersetzungszeichenfolge kann nicht ohne weiteres durch ein Reguläres Ausdrucksersetzungsmuster angegeben werden.
  • Die Ersatzzeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmende Zeichenfolge ausgeführt wurde.
  • Die Ersetzungszeichenfolge resultiert aus der bedingten Verarbeitung.

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

Weitere Informationen zu startatfinden Sie im Abschnitt Hinweise von Match(String, Int32).

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

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 dem MatchEvaluator Delegaten zu entsprechen.

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

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

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Weitere Informationen

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

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

Ausnahmen

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

input, pattern oder replacement ist null.

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

Beispiele

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

using System;
using System.Text.RegularExpressions;

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

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

Im folgenden Beispiel wird die Replace(String, String, String) -Methode verwendet, um die 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. 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 = @"\\\\(?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 regulärer 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 aufeinanderfolgenden umgekehrten Schrägstrichen (\) Da der umgekehrte Schrägstrich als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich versehen werden.
(?i:" + Environment.MachineName + ") Führen Sie eine Übereinstimmung zwischen Groß- und Kleinschreibung der Zeichenfolge aus, die von der Environment.MachineName -Eigenschaft zurückgegeben wird.
(?:\.\w+)* Entspricht dem Punktzeichen (.) gefolgt von einem oder mehreren Wortzeichen. Diese Übereinstimmung kann 0 oder mehrere Male auftreten. Der übereinstimmenden Teilausdruck wird nicht erfasst.
\\ Entspricht einem umgekehrten Schrägstrich (\).
((?i:[" + driveNames + "])) Führen Sie eine Übereinstimmung zwischen Groß- und Kleinschreibung der Zeichenklasse durch, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist der erste erfasste Teilausdruck.
\$ Stimmen Sie mit dem Literalzeichen dollar ($) überein.

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

Hinweise

Die statischen Replace Methoden entsprechen dem Erstellen eines Regex Objekts mit dem angegebenen regulären Ausdrucksmuster und dem Aufrufen der instance-Methode Replace.

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

Der replacement Parameter gibt die Zeichenfolge an, die jede Übereinstimmung in inputersetzen soll. replacement kann aus einer beliebigen Kombination von Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die von der test Erfassungsgruppe abgeglichen wird, falls vorhanden, gefolgt von der Zeichenfolge "b". Das Zeichen * wird innerhalb eines Ersatzmusters nicht als Metazeichen erkannt.

Hinweis

Ersetzungen sind die einzigen Elemente der Regulären Ausdruckssprache, die in einem Ersatzmuster erkannt werden. Alle anderen Elemente der Sprache regulärer Ausdrücke, einschließlich Zeichen-Escapes, sind nur in regulären Ausdrucksmustern zulässig und werden in Ersetzungsmustern nicht erkannt.

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Bei dieser Methode wird ein Timeout nach einem Intervall ausgeführt, das dem Standard-Timeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der verhindert, dass die Methode ein Timeout ausgibt. Die empfohlene statische Methode zum Ersetzen einer Musterüberstimmung ist Replace(String, String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

Gilt für:

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

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

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

Parameter

input
String

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.

pattern
String

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

evaluator
MatchEvaluator

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

options
RegexOptions

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

matchTimeout
TimeSpan

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

Gibt zurück

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

Ausnahmen

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

input, pattern oder evaluator ist null.

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

- oder -

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

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

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die einzelnen Wörter aus einer Zeichenfolge zu extrahieren, und dann wird ein MatchEvaluator Delegat verwendet, um eine Methode namens WordScramble aufzurufen, die die einzelnen Buchstaben im Wort verschlüsselt. 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 \w+ für reguläre Ausdrücke entspricht mindestens einem Wortzeichen. Die Engine für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis sie auf ein Nicht-Wortzeichen trifft, z. B. ein Leerzeichen. Der Aufruf der Replace(String, String, MatchEvaluator, RegexOptions) -Methode enthält die RegexOptions.IgnorePatternWhitespace Option, sodass der Kommentar im Muster \w+ # Matches all the characters in a word. des regulären Ausdrucks 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 einem regulären Ausdruck zu ersetzen, wenn eine der folgenden Bedingungen erfüllt ist:

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

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

  • Wenn die Ersetzungszeichenfolge aus bedingter Verarbeitung resultiert.

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

Der pattern Parameter besteht aus Elementen der Regulären Ausdruckssprache, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Schnellreferenz.

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 dem MatchEvaluator Delegaten zu entsprechen.

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

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

Wenn Sie für den options Parameter angebenRightToLeft, 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 Zeitüberschreitung vorliegt. Das Festlegen eines Timeoutintervalls verhindert, dass reguläre Ausdrücke, die auf übermäßiger Rückverfolgung angewiesen sind, als "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 Backtracking. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine Ausnahme aus RegexMatchTimeoutException . matchTimeout Überschreibt jeden Standardmäßigen Timeoutwert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie angeben InfiniteMatchTimeout, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Timeouts sollten sie jedoch nur unter den folgenden Bedingungen deaktivieren:

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

  • Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, Nicht-Übereinstimmungen und Fast-Übereinstimmungen effizient verarbeitet.

  • Wenn das Muster des regulären Ausdrucks keine Sprachelemente enthält, von denen bekannt ist, dass sie bei der Verarbeitung einer fast übereinstimmung übermäßigen Rückverfolgung verursachen.

Weitere Informationen

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

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

Ausnahmen

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

input, pattern oder evaluator ist null.

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

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

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die einzelnen Wörter aus einer Zeichenfolge zu extrahieren, und dann wird ein MatchEvaluator Delegat verwendet, um eine Methode namens WordScramble aufzurufen, die die einzelnen Buchstaben im Wort verschlüsselt. 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 \w+ für reguläre Ausdrücke entspricht mindestens einem Wortzeichen. Die Engine für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis sie auf ein Nicht-Wortzeichen trifft, z. B. ein Leerzeichen. Der Aufruf der Replace(String, String, MatchEvaluator, RegexOptions) -Methode enthält die RegexOptions.IgnorePatternWhitespace Option, sodass der Kommentar im Muster \w+ # Matches all the characters in a word. des regulären Ausdrucks 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();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

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

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

Hinweise

Die Regex.Replace(String, String, MatchEvaluator, RegexOptions) -Methode ist nützlich, um eine Übereinstimmung mit einem regulären Ausdruck in zu ersetzen, wenn eine der folgenden Bedingungen zutrifft:

  • Die Ersetzungszeichenfolge kann nicht ohne weiteres durch ein Reguläres Ausdrucksersetzungsmuster angegeben werden.

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

  • Die Ersetzungszeichenfolge resultiert aus der bedingten Verarbeitung.

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

Der pattern Parameter besteht aus Elementen der Regulären Ausdruckssprache, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Schnellreferenz.

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 dem MatchEvaluator Delegaten zu entsprechen.

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

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

Wenn Sie für den options Parameter angebenRightToLeft, 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.

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Weitere Informationen

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

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 des 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 und die Environment.GetLogicalDrives -Methode einzuschließen, um die Namen der logischen Laufwerke einzuschließen. Bei allen Zeichenfolgenvergleichen mit regulären Ausdrücken wird die Groß-/Kleinschreibung nicht beachtet, und bei jedem einzelnen Ersetzungsvorgang tritt ein Zeitüberschreitungsintervall auf, wenn in 0,5 Sekunden keine Übereinstimmung 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
\\\\ Entspricht zwei aufeinander folgenden umgekehrten Schrägstrichzeichen (\). Da der umgekehrte Schrägstrich als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich versehen werden.
+ Environment.MachineName + Entspricht der Zeichenfolge, die von der Environment.MachineName -Eigenschaft zurückgegeben wird.
(?:\.\w+)* Entspricht dem Punktzeichen (.), gefolgt von einem oder mehreren Wortzeichen. Diese Übereinstimmung kann 0 oder mehrmals auftreten. Der übereinstimmene Teilausdruck wird nicht erfasst.
\\ Entspricht einem umgekehrten Schrägstrich (\).
([" + driveNames + "]) Entspricht der Zeichenklasse, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist der erste erfasste Teilausdruck.
\$ Entspricht dem literalen Dollarzeichen ($).

Das Ersetzungsmuster $1 ersetzt die gesamte Übereinstimmung durch den ersten erfassten Teilausdruck. Das heißt, er ersetzt den UNC-Computer und den Namen des Laufwerks durch den Laufwerkbuchstaben.

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 instance-Methode 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 Regular Expressions and Regular Expression Language – Kurzreferenz. Wenn Sie für den options Parameter angebenRightToLeft, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und bewegt 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 inputersetzen soll. replacement kann aus einer beliebigen Kombination von Literaltext und Ersetzungen bestehen. Beispielsweise fügt das Ersetzungsmuster a*${test}b die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die von der test Erfassungsgruppe abgeglichen wird, sofern vorhanden, gefolgt von der Zeichenfolge "b". Das Zeichen * wird innerhalb eines Ersetzungsmusters nicht als Metazeichen 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 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 Zeitüberschreitung vorliegt. Das Festlegen eines Timeoutintervalls 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 Ausnahme aus RegexMatchTimeoutException . matchTimeout überschreibt jeden Standardtimeoutwert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Da die Methode unverändert zurückgibt input , wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout Parameter auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie angeben InfiniteMatchTimeout, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung. Sie sollten Timeouts jedoch nur unter den folgenden Bedingungen deaktivieren:

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

  • Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass Übereinstimmungen, Nicht-Übereinstimmungen und Fast-Übereinstimmungen effizient verarbeitet werden.

  • Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, von denen bekannt ist, dass sie bei der Verarbeitung einer nahen Übereinstimmung eine übermäßige Rückverfolgung verursachen.

Weitere Informationen

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

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 Replace(String, String, String, RegexOptions) -Methode verwendet, um die Namen des lokalen Computers und des 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 mit regulären Ausdrücken wird die Groß-/Kleinschreibung nicht beachtet. 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);
         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
\\\\ Entspricht zwei aufeinander folgenden umgekehrten Schrägstrichzeichen (\). Da der umgekehrte Schrägstrich als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich versehen werden.
+ Environment.MachineName + Entspricht der Zeichenfolge, die von der Environment.MachineName -Eigenschaft zurückgegeben wird.
(?:\.\w+)* Entspricht dem Punktzeichen (.), gefolgt von einem oder mehreren Wortzeichen. Diese Übereinstimmung kann 0 oder mehrmals auftreten. Der übereinstimmene Teilausdruck wird nicht erfasst.
\\ Entspricht einem umgekehrten Schrägstrich (\).
([" + driveNames + "]) Entspricht der Zeichenklasse, die aus den einzelnen Laufwerkbuchstaben besteht. Diese Übereinstimmung ist der erste erfasste Teilausdruck.
\$ Entspricht dem literalen Dollarzeichen ($).

Das Ersetzungsmuster $1 ersetzt die gesamte Übereinstimmung durch den ersten erfassten Teilausdruck. Das heißt, er ersetzt den UNC-Computer und den Namen des Laufwerks durch den Laufwerkbuchstaben.

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 instance-Methode 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 Regular Expressions and Regular Expression Language – Kurzreferenz. Wenn Sie für den options Parameter angebenRightToLeft, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und bewegt 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 inputersetzen soll. replacement kann aus einer beliebigen Kombination von Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die von der test Erfassungsgruppe abgeglichen wird, falls vorhanden, gefolgt von der Zeichenfolge "b". Das Zeichen * wird innerhalb eines Ersatzmusters nicht als Metazeichen erkannt.

Hinweis

Ersetzungen sind die einzigen Elemente der Regulären Ausdruckssprache, die in einem Ersatzmuster erkannt werden. Alle anderen Elemente der Sprache regulärer Ausdrücke, einschließlich Zeichen-Escapes, sind nur in regulären Ausdrucksmustern zulässig und werden in Ersetzungsmustern nicht erkannt.

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Bei dieser Methode tritt ein Timeout nach einem Intervall auf, das dem Standardtimeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der ein Timeout der Methode verhindert. Die empfohlene statische Methode zum Ersetzen einer Musterüberstimmung ist Replace(String, String, String, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

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

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 Codebeispiel wird eine originale Zeichenfolge angezeigt, jedes Wort in der ursprünglichen Zeichenfolge übereinstimmt, das erste Zeichen jeder Übereinstimmung in Großbuchstaben konvertiert und dann die konvertierte Zeichenfolge angezeigt.

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 erfüllt ist:

  • Die Ersetzungszeichenfolge kann nicht ohne weiteres durch ein Reguläres Ausdrucksersetzungsmuster angegeben werden.

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

  • Die Ersetzungszeichenfolge resultiert aus der bedingten Verarbeitung.

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

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

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 dem MatchEvaluator Delegaten zu entsprechen.

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

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

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Weitere Informationen

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

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 verwenden. Es verwendet den regulären Ausdruck \w*(ie|ei)\w* , um Wörtern zu entsprechen, die die Zeichen "ie" oder "ei" enthalten. Es übergibt die erste Hälfte der übereinstimmenden Wörter an die ReverseLetter -Methode, die wiederum die Replace(String, String, String, RegexOptions) -Methode verwendet, um "i" und "e" in der übereinstimmenden Zeichenfolge umzukehren. Die übrigen Wörter bleiben unverändert.

using System;
using System.Text.RegularExpressions;

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

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

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

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

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

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

Das Muster ([ie])([ie]) des regulären Ausdrucks in der ReverseLetter Methode stimmt mit dem ersten "i" oder "e" im Diphthong "ie" oder "ei" überein und weist den Buchstaben der ersten Erfassungsgruppe zu. Es 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 $2$1aufgerufen wird.

Hinweise

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

  • Die Ersetzungszeichenfolge kann nicht ohne weiteres durch ein Reguläres Ausdrucksersetzungsmuster angegeben werden.

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

  • Die Ersetzungszeichenfolge resultiert aus der bedingten Verarbeitung.

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

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

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 dem MatchEvaluator Delegaten zu entsprechen.

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

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

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Weitere Informationen

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

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 dann wird ein MatchEvaluator Delegat verwendet, um eine Methode namens WordScramble aufzurufen, die die einzelnen Buchstaben im Wort verschlüsselt. 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 \w+ für reguläre Ausdrücke entspricht mindestens einem Wortzeichen. Die Engine für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis sie auf ein Nicht-Wortzeichen trifft, z. B. ein Leerzeichen.

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 einem regulären Ausdruck zu ersetzen, wenn eine der folgenden Bedingungen erfüllt ist:

  • Die Ersetzungszeichenfolge kann nicht ohne weiteres durch ein Reguläres Ausdrucksersetzungsmuster angegeben werden.

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

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

Der pattern Parameter besteht aus Elementen der Regulären Ausdruckssprache, die die übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions and Regular Expression Language – Schnellreferenz.

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 dem MatchEvaluator Delegaten zu entsprechen.

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

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

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Hinweise für Aufrufer

Bei dieser Methode wird ein Timeout nach einem Intervall ausgeführt, das dem Standard-Timeoutwert der Anwendungsdomäne entspricht, in der sie aufgerufen wird. Wenn kein Timeoutwert für die Anwendungsdomäne definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der verhindert, dass die Methode ein Timeout ausgibt. Die empfohlene statische Methode zum Auswerten und Ersetzen einer Musterüberstimmung ist Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

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

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 (\w)\1 des regulären Ausdrucks entspricht aufeinanderfolgenden Vorkommen eines einzelnen Zeichens und weist das erste Vorkommen der ersten Erfassungsgruppe zu. Das Ersetzungsmuster $1 ersetzt die gesamte Übereinstimmung durch die erste erfasste Gruppe.

using System;
using System.Text.RegularExpressions;

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

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

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

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

Hinweise

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

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

Hinweis

Ersetzungen sind die einzigen Elemente der Regulären Ausdruckssprache, die in einem Ersatzmuster erkannt werden. Alle anderen Elemente der Sprache regulärer Ausdrücke, einschließlich Zeichen-Escapes, sind nur in regulären Ausdrucksmustern zulässig und werden in Ersetzungsmustern nicht erkannt.

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Weitere Informationen

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

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

Ausnahmen

input oder replacement ist null.

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

Beispiele

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

using System;
using System.Text.RegularExpressions;

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

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

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

using System;
using System.Text.RegularExpressions;

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

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

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

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

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

Muster BESCHREIBUNG
\p{Sc} Übereinstimmung mit einem Währungssymbol. {Sc} bezeichnet jedes Zeichen, das ein Mitglied des Unicode-Symbols ist, Kategorie Währung.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.
(\p{Sc}\s?)? Entspricht null oder einem Vorkommen der Kombination eines Währungssymbols gefolgt von null oder einem Leerzeichen. Dies ist die erste Erfassungsgruppe.
\d+ Entsprechung für mindestens eine Dezimalstelle finden.
\.? Entspricht null oder einem Vorkommen eines Punkts (wird als Dezimaltrennzeichen verwendet).
((?<=\.)\d+)? Wenn ein Punkt das vorherige Zeichen ist, entsprechen Sie einer oder mehreren Dezimalstellen. Dieses Muster kann entweder 0 oder einmal abgeglichen werden.
(\d+\.?((?<=\.)\d+)?) Entsprechen Sie dem Muster einer oder mehrerer 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, stimmen Sie mit einer leeren Zeichenfolge überein. Andernfalls können Sie mit null oder einem Leerzeichen gefolgt von einem Währungssymbol übereinstimmen.

Hinweise

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

Der replacement Parameter gibt die Zeichenfolge an, die jede Übereinstimmung in inputersetzen soll. replacement kann aus einer beliebigen Kombination von Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die von der test Erfassungsgruppe abgeglichen wird, falls vorhanden, gefolgt von der Zeichenfolge "b". Das Zeichen * wird innerhalb eines Ersatzmusters nicht als Metazeichen erkannt.

Hinweis

Ersetzungen sind die einzigen Elemente der Regulären Ausdruckssprache, die in einem Ersatzmuster erkannt werden. Alle anderen Elemente der Sprache regulärer Ausdrücke, einschließlich Zeichen-Escapes, sind nur in regulären Ausdrucksmustern zulässig und werden in Ersetzungsmustern nicht erkannt.

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Weitere Informationen

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

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

Das folgende Beispiel doppelt leert alle bis auf die erste Zeile einer Zeichenfolge. Es definiert ein Reguläres Ausdrucksmuster , ^.*$das einer Textzeile entspricht, ruft die Match(String) -Methode auf, um der ersten Zeile der Zeichenfolge zu entsprechen, und verwendet die Match.Index Eigenschaften und Match.Count , um die Startposition 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
^ Entspricht dem Anfang einer Zeile. (Beachten Sie, dass das Regex Objekt mithilfe der RegexOptions.Multiline Option instanziiert wurde. Andernfalls würde diese Zeichenklasse nur mit dem Anfang der Eingabezeichenfolge übereinstimmen.)
.* Übereinstimmung mit keinem oder mehreren beliebigen Zeichen.
$ Stimmen Sie mit dem Ende einer Zeile überein. (Beachten Sie, dass das Regex Objekt mithilfe der RegexOptions.Multiline Option instanziiert wurde. Andernfalls würde diese Zeichenklasse nur mit dem Anfang der Eingabezeichenfolge übereinstimmen.)

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

Hinweise

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

Weitere Informationen zu startatfinden Sie im Abschnitt Hinweise von Match(String, Int32).

Der replacement Parameter gibt die Zeichenfolge an, die jede Übereinstimmung in inputersetzen soll. replacement kann aus einer beliebigen Kombination von Literaltext und Ersetzungen bestehen. Das Ersetzungsmuster a*${test}b fügt beispielsweise die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die von der test Erfassungsgruppe abgeglichen wird, falls vorhanden, gefolgt von der Zeichenfolge "b". Das Zeichen * wird innerhalb eines Ersatzmusters nicht als Metazeichen erkannt.

Hinweis

Ersetzungen sind die einzigen Elemente der Regulären Ausdruckssprache, die in einem Ersatzmuster erkannt werden. Alle anderen Elemente der Sprache regulärer Ausdrücke, einschließlich Zeichen-Escapes, sind nur in regulären Ausdrucksmustern zulässig und werden in Ersetzungsmustern nicht erkannt.

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

Da die Methode unverändert zurückgegeben input wird, wenn keine Übereinstimmung vorhanden ist, können Sie die Object.ReferenceEquals -Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung der Eingabezeichenfolge vorgenommen hat.

Weitere Informationen

Gilt für: