Regex.Replace Methode

Referenz

Definition

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Ersetzt in einer angegebenen Eingabezeichenfolge Zeichenfolgen, die einem Muster für reguläre Ausdrücke mit einer angegebenen Ersetzungszeichenfolge entsprechen.

Überlädt

Replace(String, MatchEvaluator, Int32, Int32)	Ersetzt in einer angegebenen Eingabeunterzeichenfolge eine angegebene maximale Anzahl von Zeichenfolgen, die einem Muster für reguläre Ausdrücke entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird.
Replace(String, String, String)	Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine angegebene Ersetzungszeichenfolge.
Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)	Ersetzt in einer angegebenen Eingabezeichenfolge alle Teilzeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird. Zusätzliche Parameter geben Optionen an, die den Abgleichsvorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.
Replace(String, String, MatchEvaluator, RegexOptions)	Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird. Angegebene Optionen ändern den Abgleichsvorgang.
Replace(String, String, String, RegexOptions, TimeSpan)	Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine angegebene Ersetzungszeichenfolge. Zusätzliche Parameter geben Optionen an, die den Abgleichsvorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.
Replace(String, String, String, RegexOptions)	Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine angegebene Ersetzungszeichenfolge. Angegebene Optionen ändern den Abgleichsvorgang.
Replace(String, MatchEvaluator)	Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird.
Replace(String, MatchEvaluator, Int32)	Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene maximale Anzahl von Zeichenfolgen, die einem Muster für reguläre Ausdrücke entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird.
Replace(String, String, MatchEvaluator)	Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird.
Replace(String, String, Int32)	Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene maximale Anzahl von Zeichenfolgen, die einem Muster für reguläre Ausdrücke mit einer angegebenen Ersetzungszeichenfolge entsprechen.
Replace(String, String)	Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem Muster für reguläre Ausdrücke mit einer angegebenen Ersetzungszeichenfolge entsprechen.
Replace(String, String, Int32, Int32)	Ersetzt in einer angegebenen Eingabeunterzeichenfolge eine angegebene maximale Anzahl von Zeichenfolgen, die einem Muster für reguläre Ausdrücke mit einer angegebenen Ersetzungszeichenfolge entsprechen.

Replace(String, MatchEvaluator, Int32, Int32)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabeunterzeichenfolge eine angegebene maximale Anzahl von Zeichenfolgen, die einem Muster für reguläre Ausdrücke entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird.

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

evaluator: MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung untersucht und entweder die ursprüngliche übereinstimmende Zeichenfolge oder eine Ersetzungszeichenfolge zurückgibt.

count: Int32

Die maximale Anzahl der Vorkommen des Ersatzes.

startat: Int32

Die Zeichenposition in der Eingabezeichenfolge, an der die Suche beginnt.

Gibt zurück

String

Eine neue Zeichenfolge, die mit der Eingabezeichenfolge identisch ist, mit der Ausnahme, dass eine Ersetzungszeichenfolge anstelle jeder übereinstimmenden Zeichenfolge verwendet wird. Wenn das Muster für reguläre Ausdrücke in der aktuellen Instanz nicht übereinstimmt, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentNullException

input oder evaluator ist null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Hinweise

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

Die Ersetzungszeichenfolge kann nicht einfach durch ein Ersetzungsmuster für reguläre Ausdrücke angegeben werden.
Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmenden Zeichenfolge durchgeführt wurde.
Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

Die Methode entspricht dem Aufrufen der Regex.Matches(String, Int32)-Methode und dem Übergeben der ersten 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 Muster, das vom Konstruktor für das aktuelle Regex-Objekt definiert ist.

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

Die 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 durch den 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 Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

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

Weitere Informationen

Gilt für:

Replace(String, String, String)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, 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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

Das muster des regulären Ausdrucks, das übereinstimmen soll.

replacement: String

Die Ersetzungszeichenfolge.

Gibt zurück

String

Eine neue Zeichenfolge, die mit der Eingabezeichenfolge identisch ist, mit der Ausnahme, dass die Ersetzungszeichenfolge die Stelle jeder übereinstimmenden Zeichenfolge ist. Wenn pattern in der aktuellen Instanz nicht übereinstimmen, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

input, patternoder replacement ist null.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

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

using System;
using System.Text.RegularExpressions;

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

Imports System.Text.RegularExpressions

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

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

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

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

Die folgende Tabelle zeigt, wie das Muster für reguläre Ausdrücke interpretiert wird.

Muster	Beschreibung
`\\\\`	Stimmen Sie zwei aufeinander folgende umgekehrte Schrägstriche (`\`) überein. Da das umgekehrte Schrägstrichzeichen als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich escapet werden.
`(?i:" + Environment.MachineName + ")`	Führen Sie eine Übereinstimmung zwischen Groß- und Kleinschreibung der Zeichenfolge durch, die von der Environment.MachineName-Eigenschaft zurückgegeben wird.
`(?:\.\w+)*`	Entspricht dem Punktzeichen (`.`) gefolgt von einem oder mehreren Wortzeichen. Diese Übereinstimmung kann null oder mehr vorkommen. Der übereinstimmene Unterausdruck wird nicht erfasst.
`\\`	Entspricht einem umgekehrten Schrägstrich (`\`) Zeichen.
`((?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 Unterausdruck.
`\$`	Entspricht dem Literal-Dollarzeichen (`$`) Zeichen.

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

Hinweise

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

Der parameter replacement gibt die Zeichenfolge an, die jede Übereinstimmung in inputersetzt. replacement kann aus einer beliebigen Kombination aus Literaltext und Ersetzungenbestehen. Beispielsweise fügt das Ersetzungsmuster a*${test}b die Zeichenfolge "a*" gefolgt von der Teilzeichenfolge ein, die mit der test-Aufnahmegruppe übereinstimmt, sofern vorhanden, gefolgt von der Zeichenfolge "b". Das *-Zeichen wird nicht als Metacharacter innerhalb eines Ersetzungsmusters erkannt.

Anmerkung

Ersetzungen sind die einzigen Elemente der regulären Ausdruckssprache, die in einem Ersetzungsmuster erkannt werden. Alle anderen Sprachelemente mit regulären Ausdrücken, einschließlich Zeichen escapes, sind nur in mustern regulären Ausdrücken 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 kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist oder der Timeoutwert Regex.InfiniteMatchTimeoutist, wird keine Ausnahme ausgelöst.

Hinweise für Aufrufer

Diese Methode timeout nach einem Intervall, 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, wodurch verhindert wird, dass die Methode einen Timeoutzeitpunkt erhält. Die empfohlene statische Methode zum Ersetzen einer Musterausstimmung 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)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabezeichenfolge alle Teilzeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird. Zusätzliche Parameter geben Optionen an, die den Abgleichsvorgang 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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

Das muster des regulären Ausdrucks, das übereinstimmen soll.

evaluator: MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung untersucht und entweder die ursprüngliche übereinstimmende Zeichenfolge oder eine Ersetzungszeichenfolge zurückgibt.

options: RegexOptions

Eine bitweise Kombination von Enumerationswerten, die Optionen für den Abgleich bereitstellen.

matchTimeout: TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, um anzugeben, dass die Methode kein Timeout hat.

Gibt zurück

String

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

input, patternoder evaluator ist null.

ArgumentOutOfRangeException

options ist keine gültige bitweise Kombination aus RegexOptions Werten.

-oder-

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

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

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

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

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

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

Imports System.Collections
Imports System.Text.RegularExpressions

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

Hinweise

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

Wenn die Ersetzungszeichenfolge nicht einfach durch ein Ersetzungsmuster für reguläre Ausdrücke angegeben werden kann.
Wenn die Ersetzungszeichenfolge aus einer Verarbeitung resultiert, die für die übereinstimmenden Zeichenfolge ausgeführt wurde.
Wenn die Ersetzungszeichenfolge aus der bedingten Verarbeitung resultiert.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

Wenn Sie RightToLeft für den parameter options angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und wird nach links verschoben. andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und wird nach rechts verschoben.

Der matchTimeout-Parameter gibt an, wie lange eine Musterabgleichsmethode versucht werden soll, eine Übereinstimmung zu finden, bevor es zu einem Zeitüberschreitung kommt. Das Festlegen eines Timeoutintervalls verhindert, dass reguläre Ausdrücke, die auf übermäßigem Rückverfolgungsvorgang 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 Backtracking-. Wenn in diesem Zeitintervall keine Übereinstimmung gefunden wird, löst die Methode eine RegexMatchTimeoutException Ausnahme aus. matchTimeout überschreibt jeden Standardtimeoutwert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.

Hinweise für Aufrufer

Es wird empfohlen, den parameter matchTimeout auf einen geeigneten Wert festzulegen, z. B. zwei Sekunden. Wenn Sie Timeouts deaktivieren, indem Sie InfiniteMatchTimeoutangeben, bietet das Modul für reguläre Ausdrücke 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. Dadurch wird Text ausgeschlossen, der dynamisch von Benutzern eingegeben wurde.
Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, Nicht-Übereinstimmungen und nahe Übereinstimmungen effizient verarbeitet.
Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen zu übermäßigem Rückverfolgungsverhalten bei der Verarbeitung einer Nahübereinstimmung führen.

Weitere Informationen

Gilt für:

Replace(String, String, MatchEvaluator, RegexOptions)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird. Angegebene Optionen ändern den Abgleichsvorgang.

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

Das muster des regulären Ausdrucks, das übereinstimmen soll.

evaluator: MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung untersucht und entweder die ursprüngliche übereinstimmende Zeichenfolge oder eine Ersetzungszeichenfolge zurückgibt.

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für den Abgleich bereitstellen.

Gibt zurück

String

Eine neue Zeichenfolge, die mit der Eingabezeichenfolge identisch ist, mit der Ausnahme, dass eine Ersetzungszeichenfolge anstelle jeder übereinstimmenden Zeichenfolge verwendet wird. Wenn pattern in der aktuellen Instanz nicht übereinstimmen, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

input, patternoder evaluator ist null.

ArgumentOutOfRangeException

options ist keine gültige bitweise Kombination aus RegexOptions Werten.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

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 regulären Ausdrücken zu ersetzen, wenn eine der folgenden Bedingungen zutrifft:

Die Ersetzungszeichenfolge kann nicht einfach durch ein Ersetzungsmuster für reguläre Ausdrücke angegeben werden.
Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmenden Zeichenfolge durchgeführt wurde.
Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

Weitere Informationen

Gilt für:

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

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem angegebenen regulären Ausdruck entsprechen, durch eine angegebene Ersetzungszeichenfolge. Zusätzliche Parameter geben Optionen an, die den Abgleichsvorgang 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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

Das muster des regulären Ausdrucks, das übereinstimmen soll.

replacement: String

Die Ersetzungszeichenfolge.

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für den Abgleich bereitstellen.

matchTimeout: TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, um anzugeben, dass die Methode kein Timeout hat.

Gibt zurück

String

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

input, patternoder replacement ist null.

ArgumentOutOfRangeException

options ist keine gültige bitweise Kombination aus RegexOptions Werten.

-oder-

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

RegexMatchTimeoutException

Ein Timeout ist 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 den lokalen Computer und laufwerksnamen 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 wird ein Zeitüberschreitungen auftreten, wenn eine Übereinstimmung in 0,5 Sekunden nicht gefunden werden kann. Um das Beispiel erfolgreich auszuführen, sollten Sie die Literalzeichenfolge "MyMachine" durch ihren lokalen Computernamen ersetzen.

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

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

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

Die folgende Tabelle zeigt, wie das Muster für reguläre Ausdrücke interpretiert wird.

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

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

Hinweise

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

Der pattern-Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu übereinstimmende Zeichenfolge symbolisch beschreiben. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Regular Expressions und Regular Expression Language – Kurzübersicht. Wenn Sie RightToLeft für den parameter options angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabezeichenfolge und wird nach links verschoben. andernfalls beginnt die Suche am Anfang der Eingabezeichenfolge und wird nach rechts verschoben.

Anmerkung

Hinweise für Aufrufer

Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet wird oder aus statischem Text besteht. Dadurch wird Text ausgeschlossen, der dynamisch von Benutzern eingegeben wurde.
Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, Nicht-Übereinstimmungen und nahe Übereinstimmungen effizient verarbeitet.
Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen zu übermäßigem Rückverfolgungsverhalten bei der Verarbeitung einer Nahübereinstimmung führen.

Weitere Informationen

Gilt für:

Replace(String, String, String, RegexOptions)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

Das muster des regulären Ausdrucks, das übereinstimmen soll.

replacement: String

Die Ersetzungszeichenfolge.

options: RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für den Abgleich bereitstellen.

Gibt zurück

String

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

input, patternoder replacement ist null.

ArgumentOutOfRangeException

options ist keine gültige bitweise Kombination aus RegexOptions Werten.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

Im folgenden Beispiel wird die Replace(String, String, String, RegexOptions)-Methode verwendet, um den lokalen Computer und laufwerksnamen 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 ihren lokalen Computernamen ersetzen.

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

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

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

Die folgende Tabelle zeigt, wie das Muster für reguläre Ausdrücke interpretiert wird.

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

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

Hinweise

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

Anmerkung

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Replace(String, MatchEvaluator)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

evaluator: MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung untersucht und entweder die ursprüngliche übereinstimmende Zeichenfolge oder eine Ersetzungszeichenfolge zurückgibt.

Gibt zurück

String

Ausnahmen

ArgumentNullException

input oder evaluator ist null.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

Im folgenden Codebeispiel wird eine ursprüngliche Zeichenfolge angezeigt, die jedem Wort in der ursprünglichen Zeichenfolge entspricht, das erste Zeichen jeder Übereinstimmung in Großbuchstaben konvertiert und dann die konvertierte Zeichenfolge anzeigt.

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 regulären Ausdrücken zu ersetzen, wenn eine der folgenden Bedingungen zutrifft:

Die Ersetzungszeichenfolge kann nicht einfach durch ein Ersetzungsmuster für reguläre Ausdrücke angegeben werden.
Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmenden Zeichenfolge durchgeführt wurde.
Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

Weitere Informationen

Gilt für:

Replace(String, MatchEvaluator, Int32)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene maximale Anzahl von Zeichenfolgen, die einem Muster für reguläre Ausdrücke entsprechen, durch eine Zeichenfolge, die von einem MatchEvaluator Delegaten zurückgegeben wird.

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

evaluator: MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung untersucht und entweder die ursprüngliche übereinstimmende Zeichenfolge oder eine Ersetzungszeichenfolge zurückgibt.

count: Int32

Die maximale Anzahl der Vorkommen des Ersatzes.

Gibt zurück

String

Ausnahmen

ArgumentNullException

input oder evaluator ist null.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die Hälfte der Wörter in einer Liste absichtlich falsch zu geschrieben. Er verwendet den regulären Ausdruck \w*(ie|ei)\w*, um Wörter abzugleichen, die die Zeichen "ie" oder "ei" enthalten. Sie ü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 verbleibenden Wörter bleiben unverändert.

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Der reguläre Ausdruck \w*(ie|ei)\w* wird wie in der folgenden Tabelle dargestellt definiert.

Muster	Beschreibung
`\w*`	Entspricht null oder mehr Wortzeichen.
`(ie\|ei)`	Stimmen Sie entweder mit "ie" oder "ei" überein.
`\w*`	Entspricht null oder mehr Wortzeichen.

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

Hinweise

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

Die Ersetzungszeichenfolge kann nicht einfach durch ein Ersetzungsmuster für reguläre Ausdrücke angegeben werden.
Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmenden Zeichenfolge durchgeführt wurde.
Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

Weitere Informationen

Gilt für:

Replace(String, String, MatchEvaluator)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

pattern: String

Das muster des regulären Ausdrucks, das übereinstimmen soll.

evaluator: MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung untersucht und entweder die ursprüngliche übereinstimmende Zeichenfolge oder eine Ersetzungszeichenfolge zurückgibt.

Gibt zurück

String

Eine neue Zeichenfolge, die mit der Eingabezeichenfolge identisch ist, mit der Ausnahme, dass eine Ersetzungszeichenfolge anstelle jeder übereinstimmenden Zeichenfolge verwendet wird. Wenn pattern in der aktuellen Instanz nicht übereinstimmen, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentException

Es ist ein Fehler beim Analysieren regulärer Ausdrücke aufgetreten.

ArgumentNullException

input, patternoder evaluator ist null.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

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

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

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

Imports System.Collections
Imports System.Text.RegularExpressions

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

Hinweise

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

Die Ersetzungszeichenfolge kann nicht einfach durch ein Ersetzungsmuster für reguläre Ausdrücke angegeben werden.
Die Ersetzungszeichenfolge ergibt sich aus einer Verarbeitung, die für die übereinstimmenden Zeichenfolge durchgeführt wurde.
Die Ersetzungszeichenfolge ergibt sich aus der bedingten Verarbeitung.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

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

Hinweise für Aufrufer

Diese Methode timeout nach einem Intervall, 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, wodurch verhindert wird, dass die Methode einen Timeoutzeitpunkt erhält. Die empfohlene statische Methode zum Auswerten und Ersetzen einer Mustervergleichsart ist Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), mit der Sie das Timeoutintervall festlegen können.

Weitere Informationen

Gilt für:

Replace(String, String, Int32)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene maximale Anzahl von Zeichenfolgen, die einem Muster für reguläre Ausdrücke mit einer angegebenen Ersetzungszeichenfolge entsprechen.

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

replacement: String

Die Ersetzungszeichenfolge.

count: Int32

Die maximale Anzahl der Vorkommen des Ersatzes.

Gibt zurück

String

Eine neue Zeichenfolge, die mit der Eingabezeichenfolge identisch ist, mit der Ausnahme, dass die Ersetzungszeichenfolge die Stelle jeder übereinstimmenden Zeichenfolge ist. Wenn das Muster für reguläre Ausdrücke in der aktuellen Instanz nicht übereinstimmt, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentNullException

input oder replacement ist null.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

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

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

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

Hinweise

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

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

Anmerkung

Weitere Informationen

Gilt für:

Replace(String, String)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabezeichenfolge alle Zeichenfolgen, die einem Muster für reguläre Ausdrücke mit einer angegebenen Ersetzungszeichenfolge entsprechen.

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

replacement: String

Die Ersetzungszeichenfolge.

Gibt zurück

String

Eine neue Zeichenfolge, die mit der Eingabezeichenfolge identisch ist, mit der Ausnahme, dass die Ersetzungszeichenfolge die Stelle jeder übereinstimmenden Zeichenfolge ist. Wenn das Muster für reguläre Ausdrücke in der aktuellen Instanz nicht übereinstimmt, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentNullException

input oder replacement ist null.

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

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

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      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.

Das folgende Beispiel definiert einen regulären Ausdruck, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?und ein Ersatzmuster, $2, das 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 wie in der folgenden Tabelle dargestellt interpretiert.

Muster	Beschreibung
`\p{Sc}`	Entspricht einem Währungssymbol. `{Sc}` kennzeichnet jedes Zeichen, das Mitglied des Unicode-Symbols, der Kategorie "Währung".
`\s?`	Entspricht null 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+`	Entspricht einer oder mehreren Dezimalziffern.
`\.?`	Übereinstimmung mit Null oder einem Vorkommen eines Punkts (wird als Dezimaltrennzeichen verwendet).
`((?<=\.)\d+)?`	Wenn ein Punkt das vorherige Zeichen ist, stimmen Sie mit einer oder mehreren Dezimalziffern überein. Dieses Muster kann entweder null oder einmal abgeglichen werden.
`(\d+\.?((?<=\.)\d+)?)`	Stimmen Sie mit dem Muster einer oder mehrerer Dezimalziffern überein, gefolgt von einem optionalen Punkt und zusätzlichen Dezimalziffern. 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. Stimmen Sie andernfalls mit null oder einem Leerzeichen überein, gefolgt von einem Währungssymbol.

Hinweise

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

Anmerkung

Weitere Informationen

Gilt für:

Replace(String, String, Int32, Int32)

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Quelle:: Regex.Replace.cs

Ersetzt in einer angegebenen Eingabeunterzeichenfolge eine angegebene maximale Anzahl von Zeichenfolgen, die einem Muster für reguläre Ausdrücke mit einer angegebenen Ersetzungszeichenfolge entsprechen.

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 Zeichenfolge, die nach einer Übereinstimmung gesucht werden soll.

replacement: String

Die Ersetzungszeichenfolge.

count: Int32

Maximale Anzahl von Vorkommen des Ersetzungsbetrags.

startat: Int32

Die Zeichenposition in der Eingabezeichenfolge, an der die Suche beginnt.

Gibt zurück

String

Eine neue Zeichenfolge, die mit der Eingabezeichenfolge identisch ist, mit der Ausnahme, dass die Ersetzungszeichenfolge die Stelle jeder übereinstimmenden Zeichenfolge ist. Wenn das Muster für reguläre Ausdrücke in der aktuellen Instanz nicht übereinstimmt, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentNullException

input oder replacement ist null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Ein Timeout ist aufgetreten. Weitere Informationen zu Timeouts finden Sie im Abschnitt "Hinweise".

Beispiele

Im folgenden Beispiel werden alle Zeilen, aber die erste Zeile einer Zeichenfolge doppelt leer. Es definiert ein muster für reguläre Ausdrücke, ^.*$, das einer Textzeile entspricht, ruft die Match(String) Methode auf, um mit der ersten Zeile der Zeichenfolge übereinzustimlen, und verwendet die eigenschaften Match.Index und Match.Count, um die Anfangsposition der zweiten Zeile zu bestimmen.

using System;
using System.Text.RegularExpressions;

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

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

Imports System.Text.RegularExpressions

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

Das Muster für reguläre Ausdrücke ^.*$ wird wie in der folgenden Tabelle dargestellt definiert.

Muster	Beschreibung
`^`	Entspricht dem Anfang einer Zeile. (Beachten Sie, dass das Regex-Objekt mithilfe der Option RegexOptions.Multiline instanziiert wurde. Andernfalls stimmt diese Zeichenklasse nur mit dem Anfang der Eingabezeichenfolge überein.)
`.*`	Übereinstimmung mit einem beliebigen Zeichen null oder mehr Mal.
`$`	Entspricht dem Ende einer Zeile. (Beachten Sie, dass das Regex-Objekt mithilfe der Option RegexOptions.Multiline instanziiert wurde. Andernfalls stimmt diese Zeichenklasse nur mit dem Anfang der Eingabezeichenfolge überein.)

Die Ersetzungszeichenfolge (vbCrLf + "$&" in Visual Basic, "\n$&" in C#) fügt eine neue Zeile vor der übereinstimmenden Zeichenfolge hinzu. Beachten Sie, dass \n im C#-Beispiel vom C#-Compiler als Zeilenumbruchzeichen interpretiert wird; es stellt kein reguläres Ausdruckszeichen escape dar.

Hinweise

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

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

Anmerkung

Weitere Informationen

Gilt für:

Freigeben über

Regex.Replace Methode

Definition

Überlädt

Replace(String, MatchEvaluator, Int32, Int32)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Replace(String, String, String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Replace(String, String, MatchEvaluator, RegexOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Replace(String, String, String, RegexOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Replace(String, MatchEvaluator)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Replace(String, MatchEvaluator, Int32)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Replace(String, String, MatchEvaluator)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für: