Regex.Replace Regex.Replace Regex.Replace Regex.Replace Method

Definition

Ersetzt in einer angegebenen Eingabezeichenfolge die mit dem Muster für den regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces strings that match a regular expression pattern with a specified replacement string.

Überlädt

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Teilzeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32)

Ersetzt in einer angegebenen Eingabeteilzeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32)

Ersetzt in einer angegebenen Eingabeteilzeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine angegebene Ersetzungszeichenfolge.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, String, String) Replace(String, String, String) Replace(String, String, String) Replace(String, String, String)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

Replace(String, String, Int32) Replace(String, String, Int32) Replace(String, String, Int32) Replace(String, String, Int32)

Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit dem Muster für den regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32)

Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Teilzeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Eine bitweise Kombination von Enumerationswerten, die Optionen für Vergleiche angeben.A bitwise combination of enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input, pattern oder evaluator ist null.input, pattern, or evaluator is null.

options ist keine gültige bitweise Kombination von RegexOptions -Werten.options is not a valid bitwise combination of RegexOptions values.

- oder --or- matchTimeout ist negativ, null oder größer als ca. 24 Tage.matchTimeout is negative, zero, or greater than approximately 24 days.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die einzelnen Wörter aus einer Zeichenfolge zu extrahieren MatchEvaluator . Anschließend wird ein Delegat WordScramble verwendet, um eine Methode mit dem Namen aufzurufen, die die einzelnen Buchstaben im Wort abruft.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. Zu diesem Zweck wird von WordScramble der-Methode ein Array erstellt, das die Zeichen in der Übereinstimmung enthält.To do this, the WordScramble method creates an array that contains the characters in the match. Außerdem wird ein paralleles Array erstellt, das mit zufälligen Gleit Komma Zahlen aufgefüllt wird.It also creates a parallel array that it populates with random floating-point numbers. 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.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. Diese neu erstellte Zeichenfolge wird dann von der WordScramble -Methode zurückgegeben.This newly created string is then returned by the WordScramble method. Das Muster \w+ für reguläre Ausdrücke entspricht einem oder mehreren Wort Zeichen. das Modul für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis ein nicht-Wort Zeichen (z. b. ein Leerzeichen) gefunden wird.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character. Der aufzurufende Replace(String, String, MatchEvaluator, RegexOptions) -Methode RegexOptions.IgnorePatternWhitespace enthält die-Option, sodass der Kommentar im Muster \w+ # Matches all the characters in a word. für reguläre Ausdrücke von der Engine für reguläre Ausdrücke ignoriert wird.The call to the Replace(String, String, MatchEvaluator, RegexOptions) method includes the RegexOptions.IgnorePatternWhitespace option so that the comment in the regular expression pattern \w+ # Matches all the characters in a word. is ignored by the regular expression engine.

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, wenn eine der folgenden Bedingungen zutrifft, um eine Entsprechung für reguläre Ausdrücke zu ersetzen:The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match if any of the following conditions is true:

  • , Wenn die Ersetzungs Zeichenfolge nicht leicht durch ein Ersatz Muster für reguläre Ausdrücke angegeben werden kann.If the replacement string cannot readily be specified by a regular expression replacement pattern.

  • , Wenn die Ersetzungs Zeichenfolge aus der Verarbeitung der übereinstimmenden Zeichenfolge resultiert.If the replacement string results from some processing performed on the matched string.

  • , Wenn die Ersetzungs Zeichenfolge aus der bedingten Verarbeitung resultiert.If the replacement string results from conditional processing.

Die-Methode entspricht dem Aufrufen der Regex.Matches(String, String, RegexOptions) -Methode und dem Match übergeben der einzelnen Objekte MatchCollection in der zurück evaluator gegebenen Auflistung an den-Delegaten.The method is equivalent to calling the Regex.Matches(String, String, RegexOptions) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Die benutzerdefinierte Methode muss die folgende Signatur aufweisen, damit MatchEvaluator Sie dem Delegaten entspricht.The custom method must have the following signature to match the MatchEvaluator delegate.

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.Your custom method returns a string that replaces the matched input.

Wenn Sie für RightToLeft den options -Parameter angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabe Zeichenfolge und wird nach links verschoben. andernfalls beginnt die Suche am Anfang der Eingabe Zeichenfolge und verschiebt nach rechts.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

Der matchTimeout -Parameter gibt an, wie lange eine Muster Vergleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor eine Zeitüberschreitung auftritt. Das Festlegen eines Timeout Intervalls verhindert, dass reguläre Ausdrücke, die auf übermäßiger Rückverfolgung basieren, nicht mehr reagieren, wenn Sie Eingaben verarbeiten, die Near-Übereinstimmungen enthalten.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to "stop responding when they process input that contains near matches. Weitere Informationen finden Sie unter bewährte Methoden für reguläre Ausdrücke und Rückverfolgung.For more information, see Best Practices for Regular Expressions and Backtracking. Wenn in diesem Zeitintervall keine Entsprechung gefunden wird, löst die Methode RegexMatchTimeoutException eine-Ausnahme aus.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeoutÜberschreibt jeden Standard Timeout Wert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout -Parameter auf einen geeigneten Wert, z. b. zwei Sekunden, festzulegen.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Wenn Sie Timeouts durch angeben InfiniteMatchTimeoutvon deaktivieren, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Timeouts sollten jedoch nur unter den folgenden Bedingungen deaktiviert werden:However, you should disable time-outs only under the following conditions: : Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet ist oder aus statischem Text besteht.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.This excludes text that has been dynamically input by users.

: Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, nicht-Übereinstimmungen und NEAR-Übereinstimmungen effizient behandelt.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen eine übermäßige Rückverfolgung verursachen, wenn eine nahe Übereinstimmung verarbeitet wird.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Siehe auch

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Zusätzliche Parameter geben die Optionen an, die den entsprechenden Vorgang und ein Timeoutintervall ändern, wenn keine Übereinstimmung gefunden wird.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

replacement
String String String String

Die Ersatzzeichenfolge.The replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Ein Timeoutintervall oder InfiniteMatchTimeout, das angibt, dass die Methode kein Timeout haben sollte.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input, pattern oder replacement ist null.input, pattern, or replacement is null.

options ist keine gültige bitweise Kombination von RegexOptions -Werten.options is not a valid bitwise combination of RegexOptions values.

- oder --or- matchTimeout ist negativ, null oder größer als ca. 24 Tage.matchTimeout is negative, zero, or greater than approximately 24 days.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel wird die Replace(String, String, String, RegexOptions, TimeSpan) -Methode verwendet, um den lokalen Computer und die Laufwerks Namen in einem UNC-Pfad durch einen lokalen Dateipfad zu ersetzen.The following example uses the Replace(String, String, String, RegexOptions, TimeSpan) method to replace the local machine and drive names in a UNC path with a local file path. Der reguläre Ausdruck verwendet die Environment.MachineName -Eigenschaft, um den Namen des lokalen Computers einzuschließen Environment.GetLogicalDrives , und die-Methode, um die Namen der logischen Laufwerke einzubeziehen.The regular expression uses the Environment.MachineName property to include the name of the local computer and the Environment.GetLogicalDrives method to include the names of the logical drives. Bei allen Vergleichen von Zeichen folgen mit regulärem Ausdruck wird die Groß-/Kleinschreibung nicht beachtet, und bei jedem einzelnen Ersetzungs Vorgang wird ein Timeout festgestellt, wenn in 0,5All regular expression string comparisons are case-insensitive, and any single replacement operation times out if a match cannot be found in 0.5 second. Um das Beispiel erfolgreich auszuführen, sollten Sie die Literalzeichenfolge "MyMachine" durch den Namen Ihres lokalen Computers ersetzen.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

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:The regular expression pattern is defined by the following expression:

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

Die folgende Tabelle zeigt, wie das Muster eines regulären Ausdrucks interpretiert wird.The following table shows how the regular expression pattern is interpreted.

MusterPattern BeschreibungDescription
\\\\ Entsprechung für zwei aufeinanderfolgende umgekehrte\Schrägstriche ().\\\\ Match two consecutive backslash (\) characters. Da der umgekehrte Schrägstrich als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich versehen werden.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Entspricht der Zeichenfolge, die von der Environment.MachineName -Eigenschaft zurückgegeben wird.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Entspricht dem period (.)-Zeichen, gefolgt von einem oder mehreren Wort Zeichen.Match the period (.) character followed by one or more word characters. Diese Entsprechung kann NULL oder mehrmals vorkommen.This match can occur zero or more times. Der übereinstimmende Teil Ausdruck wird nicht erfasst.The matched subexpression is not captured.
\\ Abgleichen eines umgekehrten schräg\Strichs ().\\ Match a backslash (\) character.
([" + driveNames + "]) Vergleichen Sie die Zeichenklasse, die aus den einzelnen Laufwerk Buchstaben besteht.Match the character class that consists of the individual drive letters. Diese Entsprechung ist der erste erfasste Teil Ausdruck.This match is the first captured subexpression.
\$ Entsprechung für das Literale$Dollarzeichen ().Match the literal dollar sign ($) character.

Das Ersetzungs $1 Muster ersetzt die gesamte Entsprechung durch den ersten erfassten Teil Ausdruck.The replacement pattern $1 replaces the entire match with the first captured subexpression. Das heißt, dass der UNC-Computer und der Laufwerks Name durch den Laufwerk Buchstaben ersetzt werden.That is, it replaces the UNC machine and drive name with the drive letter.

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 ReplaceInstanzmethode.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Wenn Sie für RightToLeft den options -Parameter angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabe Zeichenfolge und wird nach links verschoben. andernfalls beginnt die Suche am Anfang der Eingabe Zeichenfolge und verschiebt nach rechts.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

Der replacement -Parameter gibt die Zeichenfolge an, in inputder die einzelnen Treffer ersetzt werden sollen.The replacement parameter specifies the string that is to replace each match in input. replacementkann aus einer beliebigen Kombination aus Literaltext und Substitutionenbestehen.replacement can consist of any combination of literal text and substitutions. Das Ersetzungs Muster a*${test}b fügt z. b. die Zeichenfolge "a *" gefolgt von der Teil Zeichenfolge test , die mit der Erfassungs Gruppe übereinstimmt, ggf. gefolgt von der Zeichenfolge "b" ein.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Das Zeichen "*" wird nicht als Metazeichen innerhalb eines Ersetzungs Musters erkannt.The * character is not recognized as a metacharacter within a replacement pattern.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungs Muster erkannt werden.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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 nicht in Ersetzungs Mustern erkannt.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Der matchTimeout -Parameter gibt an, wie lange eine Muster Vergleichsmethode versuchen sollte, eine Übereinstimmung zu finden, bevor eine Zeitüberschreitung auftritt. Das Festlegen eines Timeout Intervalls verhindert, dass reguläre Ausdrücke, die auf einer übermäßigen Rückverfolgung basieren, nicht mehr reagieren, wenn Sie Eingaben verarbeiten, die Near-Übereinstimmungen enthalten.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Weitere Informationen finden Sie unter bewährte Methoden für reguläre Ausdrücke und Rückverfolgung.For more information, see Best Practices for Regular Expressions and Backtracking. Wenn in diesem Zeitintervall keine Entsprechung gefunden wird, löst die Methode RegexMatchTimeoutException eine-Ausnahme aus.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeoutÜberschreibt jeden Standard Timeout Wert, der für die Anwendungsdomäne definiert ist, in der die Methode ausgeführt wird.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Hinweise für Aufrufer

Es wird empfohlen, den matchTimeout -Parameter auf einen geeigneten Wert, z. b. zwei Sekunden, festzulegen.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Wenn Sie Timeouts durch angeben InfiniteMatchTimeoutvon deaktivieren, bietet die Engine für reguläre Ausdrücke eine etwas bessere Leistung.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Timeouts sollten jedoch nur unter den folgenden Bedingungen deaktiviert werden:However, you should disable time-outs only under the following conditions: : Wenn die von einem regulären Ausdruck verarbeitete Eingabe von einer bekannten und vertrauenswürdigen Quelle abgeleitet ist oder aus statischem Text besteht.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Dies schließt Text aus, der von Benutzern dynamisch eingegeben wurde.This excludes text that has been dynamically input by users.

: Wenn das Muster für reguläre Ausdrücke gründlich getestet wurde, um sicherzustellen, dass es Übereinstimmungen, nicht-Übereinstimmungen und NEAR-Übereinstimmungen effizient behandelt.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Wenn das Muster für reguläre Ausdrücke keine Sprachelemente enthält, die bekanntermaßen eine übermäßige Rückverfolgung verursachen, wenn eine nahe Übereinstimmung verarbeitet wird.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Siehe auch

Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32) Replace(String, MatchEvaluator, Int32, Int32)

Ersetzt in einer angegebenen Eingabeteilzeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32 Int32 Int32 Int32

Die maximale Anzahl der Ersetzungen.The maximum number of times the replacement will occur.

startat
Int32 Int32 Int32 Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.The character position in the input string where the search begins.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. 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.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

input oder evaluator ist null.input or evaluator is null.

startat ist kleiner als 0 (null) oder größer als die Länge von input.startat is less than zero or greater than the length of input.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Hinweise

Die Regex.Replace(String, MatchEvaluator, Int32, Int32) -Methode ist nützlich, wenn eine der folgenden Bedingungen zutrifft, um eine Entsprechung für reguläre Ausdrücke zu ersetzen:The Regex.Replace(String, MatchEvaluator, Int32, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Die Ersetzungs Zeichenfolge kann nicht ohne weiteres durch ein Ersatz Muster für reguläre Ausdrücke angegeben werden.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Die Ersetzungs Zeichenfolge ergibt sich aus der Verarbeitung der übereinstimmenden Zeichenfolge.The replacement string results from some processing done on the matched string.

  • Die Ersetzungs Zeichenfolge führt zu einer bedingten Verarbeitung.The replacement string results from conditional processing.

Die-Methode entspricht dem Aufrufen der Regex.Matches(String, Int32) -Methode und dem übergeben count der ersten Match Objekte in MatchCollection der zurückgegebenen evaluator Auflistung an den-Delegaten.The method is equivalent to calling the Regex.Matches(String, Int32) method and passing the first countMatch objects in the returned MatchCollection collection to the evaluator delegate.

Der reguläre Ausdruck ist das Muster, das durch den Konstruktor für das Regex aktuelle-Objekt definiert wird.The regular expression is the pattern defined by the constructor for the current Regex object.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Die benutzerdefinierte Methode muss die folgende Signatur aufweisen, damit MatchEvaluator Sie dem Delegaten entspricht.The custom method must have the following signature to match the MatchEvaluator delegate.

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.Your custom method returns a string that replaces the matched input.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan) -Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des-Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der Regex das-Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Siehe auch

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.A bitwise combination of the enumeration values that provide options for matching.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input, pattern oder evaluator ist null.input, pattern, or evaluator is null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.options is not a valid bitwise combination of RegexOptions values.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die einzelnen Wörter aus einer Zeichenfolge zu extrahieren MatchEvaluator . Anschließend wird ein Delegat WordScramble verwendet, um eine Methode mit dem Namen aufzurufen, die die einzelnen Buchstaben im Wort abruft.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. Zu diesem Zweck wird von WordScramble der-Methode ein Array erstellt, das die Zeichen in der Übereinstimmung enthält.To do this, the WordScramble method creates an array that contains the characters in the match. Außerdem wird ein paralleles Array erstellt, das mit zufälligen Gleit Komma Zahlen aufgefüllt wird.It also creates a parallel array that it populates with random floating-point numbers. 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.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. Diese neu erstellte Zeichenfolge wird dann von der WordScramble -Methode zurückgegeben.This newly created string is then returned by the WordScramble method. Das Muster \w+ für reguläre Ausdrücke entspricht einem oder mehreren Wort Zeichen. das Modul für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis ein nicht-Wort Zeichen (z. b. ein Leerzeichen) gefunden wird.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character. Der aufzurufende Replace(String, String, MatchEvaluator, RegexOptions) -Methode RegexOptions.IgnorePatternWhitespace enthält die-Option, sodass der Kommentar im Muster \w+ # Matches all the characters in a word. für reguläre Ausdrücke von der Engine für reguläre Ausdrücke ignoriert wird.The call to the Replace(String, String, MatchEvaluator, RegexOptions) method includes the RegexOptions.IgnorePatternWhitespace option so that the comment in the regular expression pattern \w+ # Matches all the characters in a word. is ignored by the regular expression engine.

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, wenn eine der folgenden Bedingungen zutrifft, wenn eine der folgenden Bedingungen zutrifft:The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match in if any of the following conditions is true:

  • Die Ersetzungs Zeichenfolge kann nicht ohne weiteres durch ein Ersatz Muster für reguläre Ausdrücke angegeben werden.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Die Ersetzungs Zeichenfolge ergibt sich aus der Verarbeitung der übereinstimmenden Zeichenfolge.The replacement string results from some processing done on the matched string.

  • Die Ersetzungs Zeichenfolge führt zu einer bedingten Verarbeitung.The replacement string results from conditional processing.

Die-Methode entspricht dem Aufrufen der Regex.Matches(String, String, RegexOptions) -Methode und dem Match übergeben der einzelnen Objekte MatchCollection in der zurück evaluator gegebenen Auflistung an den-Delegaten.The method is equivalent to calling the Regex.Matches(String, String, RegexOptions) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Die benutzerdefinierte Methode muss die folgende Signatur aufweisen, damit MatchEvaluator Sie dem Delegaten entspricht.The custom method must have the following signature to match the MatchEvaluator delegate.

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.Your custom method returns a string that replaces the matched input.

Wenn Sie für RightToLeft den options -Parameter angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabe Zeichenfolge und wird nach links verschoben. andernfalls beginnt die Suche am Anfang der Eingabe Zeichenfolge und verschiebt nach rechts.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das Timeout Intervall überschreitet, das für die Anwendungsdomäne festgelegt wurde, in der die-Methode aufgerufen wird.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Siehe auch

Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32)

Ersetzt in einer angegebenen Eingabeteilzeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine angegebene Ersetzungszeichenfolge.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

replacement
String String String String

Die Ersatzzeichenfolge.The replacement string.

count
Int32 Int32 Int32 Int32

Die maximale Anzahl der Ersetzungen.Maximum number of times the replacement can occur.

startat
Int32 Int32 Int32 Int32

Die Zeichenposition in der Eingabezeichenfolge, an der mit der Suche begonnen wird.The character position in the input string where the search begins.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. 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.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

input oder replacement ist null.input or replacement is null.

startat ist kleiner als 0 (null) oder größer als die Länge von input.startat is less than zero or greater than the length of input.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel werden alle außer der ersten Zeile einer Zeichenfolge mit zwei Leerzeichen dargestellt.The following example double-spaces all but the first line of a string. Es definiert ein Muster für reguläre Ausdrücke ^.*$,, das mit einer Textzeile übereinstimmt Match(String) , die-Methode aufruft, um die erste Zeile der Zeichenfolge Match.Index abzugleichen, und verwendet die-Eigenschaft und die- Match.Count Eigenschaft, um die Anfangsposition der zweiten zu ermitteln. Stimmen.It defines a regular expression pattern, ^.*$, that matches a line of text, calls the Match(String) method to match the first line of the string, and uses the Match.Index and Match.Count properties to determine the starting position of the second line.

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:The regular expression pattern ^.*$ is defined as shown in the following table.

MusterPattern BeschreibungDescription
^ Übereinstimmung mit dem Anfang einer Zeile.Match the start of a line. (Beachten Sie, Regex dass das-Objekt mit der RegexOptions.Multiline -Option instanziiert wurde. andernfalls entspricht diese Zeichenklasse nur dem Anfang der Eingabe Zeichenfolge.)(Note that the Regex object was instantiated by using the RegexOptions.Multiline option; otherwise, this character class would only match the beginning of the input string.)
.* Entspricht keinem oder mehreren Zeichen.Match any character zero or more times.
$ Übereinstimmung mit dem Ende einer Zeile.Match the end of a line. (Beachten Sie, Regex dass das-Objekt mit der RegexOptions.Multiline -Option instanziiert wurde. andernfalls entspricht diese Zeichenklasse nur dem Anfang der Eingabe Zeichenfolge.)(Note that the Regex object was instantiated by using the RegexOptions.Multiline option; otherwise, this character class would only match the beginning of the input string.)

Die Ersetzungs ZeichenfolgevbCrLf + "$&" ( "\n$&" in C#Visual Basic) fügt vor der übereinstimmenden Zeichenfolge eine neue Zeile hinzu.The replacement string (vbCrLf + "$&" in Visual Basic, "\n$&" in C#) adds a new line before the matched string. Beachten Sie \n , dass C# im Beispiel vom C# Compiler als Zeilen Zeilenzeichen interpretiert wird. es stellt keinen Escapezeichen für reguläre Ausdrücke dar.Note that \n in the C# example is interpreted as the newline character by the C# compiler; it does not represent a regular expression character escape.

Hinweise

Die Suche nach Übereinstimmungen beginnt in input der Zeichenfolge an der Position, startat die durch den-Parameter angegeben wird.The search for matches starts in the input string at the position specified by the startat parameter. Der reguläre Ausdruck ist das Muster, das durch den Konstruktor für das Regex aktuelle-Objekt definiert wird.The regular expression is the pattern defined by the constructor for the current Regex object. Wenn count negativ ist, werden die Ersetzungen bis zum Ende der Zeichenfolge fortgesetzt.If count is negative, replacements continue to the end of the string. Wenn count die Anzahl der Übereinstimmungen überschreitet, werden alle Übereinstimmungen ersetzt.If count exceeds the number of matches, all matches are replaced.

Der replacement -Parameter gibt die Zeichenfolge an, in inputder die einzelnen Treffer ersetzt werden sollen.The replacement parameter specifies the string that is to replace each match in input. replacementkann aus einer beliebigen Kombination aus Literaltext und Substitutionenbestehen.replacement can consist of any combination of literal text and substitutions. Das Ersetzungs Muster a*${test}b fügt z. b. die Zeichenfolge "a *" gefolgt von der Teil Zeichenfolge test , die mit der Erfassungs Gruppe übereinstimmt, ggf. gefolgt von der Zeichenfolge "b" ein.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Das Zeichen "*" wird nicht als Metazeichen innerhalb eines Ersetzungs Musters erkannt.The * character is not recognized as a metacharacter within a replacement pattern.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungs Muster erkannt werden.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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 nicht in Ersetzungs Mustern erkannt.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan) -Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des-Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der Regex das-Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Siehe auch

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

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Durch angegebene Optionen wird die Suche nach Übereinstimmungen geändert.Specified options modify the matching operation.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

replacement
String String String String

Die Ersatzzeichenfolge.The replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Eine bitweise Kombination der Enumerationswerte, die Optionen für Vergleiche angeben.A bitwise combination of the enumeration values that provide options for matching.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input, pattern oder replacement ist null.input, pattern, or replacement is null.

options ist keine gültige bitweise Kombination von RegexOptions-Werten.options is not a valid bitwise combination of RegexOptions values.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel wird die Replace(String, String, String, RegexOptions) -Methode verwendet, um den lokalen Computer und die Laufwerks Namen in einem UNC-Pfad durch einen lokalen Dateipfad zu ersetzen.The following example uses the Replace(String, String, String, RegexOptions) method to replace the local machine and drive names in a UNC path with a local file path. Der reguläre Ausdruck verwendet die Environment.MachineName -Eigenschaft, um den Namen des lokalen Computers einzuschließen, Environment.GetLogicalDrives und die-Methode, um die Namen der logischen Laufwerke einzubeziehen.The regular expression uses the Environment.MachineName property to include the name of the local computer, and the Environment.GetLogicalDrives method to include the names of the logical drives. Bei allen Vergleichen von Zeichen folgen für reguläre Ausdrücke wird die groß-/kleinAll regular expression string comparisons are case-insensitive. Um das Beispiel erfolgreich auszuführen, sollten Sie die Literalzeichenfolge "MyMachine" durch den Namen Ihres lokalen Computers ersetzen.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

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:The regular expression pattern is defined by the following expression:

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

Die folgende Tabelle zeigt, wie das Muster eines regulären Ausdrucks interpretiert wird.The following table shows how the regular expression pattern is interpreted.

MusterPattern BeschreibungDescription
\\\\ Entsprechung für zwei aufeinanderfolgende umgekehrte\Schrägstriche ().\\\\ Match two consecutive backslash (\) characters. Da der umgekehrte Schrägstrich als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich versehen werden.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Entspricht der Zeichenfolge, die von der Environment.MachineName -Eigenschaft zurückgegeben wird.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Entspricht dem period (.)-Zeichen, gefolgt von einem oder mehreren Wort Zeichen.Match the period (.) character followed by one or more word characters. Diese Entsprechung kann NULL oder mehrmals vorkommen.This match can occur zero or more times. Der übereinstimmende Teil Ausdruck wird nicht erfasst.The matched subexpression is not captured.
\\ Abgleichen eines umgekehrten schräg\Strichs ().\\ Match a backslash (\) character.
([" + driveNames + "]) Vergleichen Sie die Zeichenklasse, die aus den einzelnen Laufwerk Buchstaben besteht.Match the character class that consists of the individual drive letters. Diese Entsprechung ist der erste erfasste Teil Ausdruck.This match is the first captured subexpression.
\$ Entsprechung für das Literale$Dollarzeichen ().Match the literal dollar sign ($) character.

Das Ersetzungs $1 Muster ersetzt die gesamte Entsprechung durch den ersten erfassten Teil Ausdruck.The replacement pattern $1 replaces the entire match with the first captured subexpression. Das heißt, dass der UNC-Computer und der Laufwerks Name durch den Laufwerk Buchstaben ersetzt werden.That is, it replaces the UNC machine and drive name with the drive letter.

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 ReplaceInstanzmethode.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Wenn Sie für RightToLeft den options -Parameter angeben, beginnt die Suche nach Übereinstimmungen am Ende der Eingabe Zeichenfolge und wird nach links verschoben. andernfalls beginnt die Suche am Anfang der Eingabe Zeichenfolge und verschiebt nach rechts.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

Der replacement -Parameter gibt die Zeichenfolge an, in inputder die einzelnen Treffer ersetzt werden sollen.The replacement parameter specifies the string that is to replace each match in input. replacementkann aus einer beliebigen Kombination aus Literaltext und Substitutionenbestehen.replacement can consist of any combination of literal text and substitutions. Das Ersetzungs Muster a*${test}b fügt z. b. die Zeichenfolge "a *" gefolgt von der Teil Zeichenfolge test , die mit der Erfassungs Gruppe übereinstimmt, ggf. gefolgt von der Zeichenfolge "b" ein.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Das Zeichen "*" wird nicht als Metazeichen innerhalb eines Ersetzungs Musters erkannt.The * character is not recognized as a metacharacter within a replacement pattern.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungs Muster erkannt werden.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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 nicht in Ersetzungs Mustern erkannt.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das Timeout Intervall überschreitet, das für die Anwendungsdomäne festgelegt wurde, in der die-Methode aufgerufen wird.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Hinweise für Aufrufer

Bei dieser Methode wird nach einem Intervall, das gleich dem Standard Timeout Wert der Anwendungsdomäne ist, in der Sie aufgerufen wird, ein Timeout festgestellt.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Wenn für die Anwendungsdomäne kein Timeout Wert definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der das Timeout der Methode verhindert.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Die empfohlene statische Methode zum Ersetzen einer Muster Übereinstimmung ist Replace(String, String, String, RegexOptions, TimeSpan), mit der Sie das Timeout Intervall festlegen können.The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Siehe auch

Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator) Replace(String, String, MatchEvaluator)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.A custom method that examines each match and returns either the original matched string or a replacement string.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input, pattern oder evaluator ist null.input, pattern, or evaluator is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die einzelnen Wörter aus einer Zeichenfolge zu extrahieren MatchEvaluator . Anschließend wird ein Delegat WordScramble verwendet, um eine Methode mit dem Namen aufzurufen, die die einzelnen Buchstaben im Wort abruft.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. Zu diesem Zweck wird von WordScramble der-Methode ein Array erstellt, das die Zeichen in der Übereinstimmung enthält.To do this, the WordScramble method creates an array that contains the characters in the match. Außerdem wird ein paralleles Array erstellt, das mit zufälligen Gleit Komma Zahlen aufgefüllt wird.It also creates a parallel array that it populates with random floating-point numbers. 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.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. Diese neu erstellte Zeichenfolge wird dann von der WordScramble -Methode zurückgegeben.This newly created string is then returned by the WordScramble method. Das Muster \w+ für reguläre Ausdrücke entspricht einem oder mehreren Wort Zeichen. das Modul für reguläre Ausdrücke fügt der Übereinstimmung weiterhin Zeichen hinzu, bis ein nicht-Wort Zeichen (z. b. ein Leerzeichen) gefunden wird.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character.

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, wenn eine der folgenden Bedingungen zutrifft, um eine Entsprechung für reguläre Ausdrücke zu ersetzen:The Regex.Replace(String, String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Die Ersetzungs Zeichenfolge kann nicht ohne weiteres durch ein Ersatz Muster für reguläre Ausdrücke angegeben werden.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Die Ersetzungs Zeichenfolge ergibt sich aus der Verarbeitung der übereinstimmenden Zeichenfolge.The replacement string results from some processing done on the matched string.

  • Die Ersetzungs Zeichenfolge führt zu einer bedingten Verarbeitung.The replacement string results from conditional processing.

Die-Methode entspricht dem Aufrufen der Regex.Matches(String, String) -Methode und dem Match übergeben der einzelnen Objekte MatchCollection in der zurück evaluator gegebenen Auflistung an den-Delegaten.The method is equivalent to calling the Regex.Matches(String, String) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Die benutzerdefinierte Methode muss die folgende Signatur aufweisen, damit MatchEvaluator Sie dem Delegaten entspricht.The custom method must have the following signature to match the MatchEvaluator delegate.

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.Your custom method returns a string that replaces the matched input.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das Timeout Intervall überschreitet, das für die Anwendungsdomäne festgelegt wurde, in der die-Methode aufgerufen wird.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Hinweise für Aufrufer

Bei dieser Methode wird nach einem Intervall, das gleich dem Standard Timeout Wert der Anwendungsdomäne ist, in der Sie aufgerufen wird, ein Timeout festgestellt.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Wenn für die Anwendungsdomäne kein Timeout Wert definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der das Timeout der Methode verhindert.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Die empfohlene statische Methode zum Auswerten und Ersetzen einer Muster Übereinstimmung ist Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), mit der Sie das Timeout Intervall festlegen können.The recommended static method for evaluating and replacing a pattern match is Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), which lets you set the time-out interval.

Siehe auch

Replace(String, String, String) Replace(String, String, String) Replace(String, String, String) Replace(String, String, String)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

pattern
String String String String

Das Muster eines regulären Ausdrucks, mit dem Übereinstimmungen gefunden werden sollen.The regular expression pattern to match.

replacement
String String String String

Die Ersatzzeichenfolge.The replacement string.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Wenn für pattern keine Übereinstimmung in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

Ein Analysefehler für reguläre Ausdrücke ist aufgetreten.A regular expression parsing error occurred.

input, pattern oder replacement ist null.input, pattern, or replacement is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck \s+definiert,, der mit einem oder mehreren Leerzeichen übereinstimmt.The following example defines a regular expression, \s+, that matches one or more white-space characters. Die Ersetzungs Zeichenfolge "" ersetzt Sie durch ein einzelnes Leerzeichen.The replacement string, " ", replaces them with a single space character.

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 die Laufwerks Namen in einem UNC-Pfad durch einen lokalen Dateipfad zu ersetzen.The following example uses the Replace(String, String, String) method to replace the local machine and drive names in a UNC path with a local file path. Der reguläre Ausdruck verwendet die Environment.MachineName -Eigenschaft, um den Namen des lokalen Computers einzuschließen, Environment.GetLogicalDrives und die-Methode, um die Namen der logischen Laufwerke einzubeziehen.The regular expression uses the Environment.MachineName property to include the name of the local computer, and the Environment.GetLogicalDrives method to include the names of the logical drives. Um das Beispiel erfolgreich auszuführen, sollten Sie die Literalzeichenfolge "MyMachine" durch den Namen Ihres lokalen Computers ersetzen.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

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:The regular expression pattern is defined by the following expression:

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

Die folgende Tabelle zeigt, wie das Muster eines regulären Ausdrucks interpretiert wird.The following table shows how the regular expression pattern is interpreted.

MusterPattern BeschreibungDescription
\\\\ Entsprechung für zwei aufeinanderfolgende umgekehrte\Schrägstriche ().\\\\ Match two consecutive backslash (\) characters. Da der umgekehrte Schrägstrich als Escapezeichen interpretiert wird, muss jeder umgekehrte Schrägstrich mit einem anderen umgekehrten Schrägstrich versehen werden.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
(?i:" + Environment.MachineName + ") Führt einen Vergleich der von der Environment.MachineName -Eigenschaft zurückgegebenen Zeichenfolge ohne Beachtung der Groß-/Kleinschreibung aus.Perform a case-insensitive match of the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Entspricht dem period (.)-Zeichen, gefolgt von einem oder mehreren Wort Zeichen.Match the period (.) character followed by one or more word characters. Diese Entsprechung kann NULL oder mehrmals vorkommen.This match can occur zero or more times. Der übereinstimmende Teil Ausdruck wird nicht erfasst.The matched subexpression is not captured.
\\ Abgleichen eines umgekehrten schräg\Strichs ().\\ Match a backslash (\) character.
((?i:[" + driveNames + "])) Führen Sie die Groß-/Kleinschreibung der Zeichenklasse aus, die aus den einzelnen Laufwerk Buchstaben besteht.Perform a case-insensitive match of the character class that consists of the individual drive letters. Diese Entsprechung ist der erste erfasste Teil Ausdruck.This match is the first captured subexpression.
\$ Entsprechung für das Literale$Dollarzeichen ().Match the literal dollar sign ($) character.

Das Ersetzungs $1 Muster ersetzt die gesamte Entsprechung durch den ersten erfassten Teil Ausdruck.The replacement pattern $1 replaces the entire match with the first captured subexpression. Das heißt, dass der UNC-Computer und der Laufwerks Name durch den Laufwerk Buchstaben ersetzt werden.That is, it replaces the UNC machine and drive name with the drive letter.

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 ReplaceInstanzmethode.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

Der pattern -Parameter besteht aus Sprachelementen für reguläre Ausdrücke, die die zu Übereinstimmungs enden Zeichen folgen symbolisch beschreiben.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Weitere Informationen zu regulären Ausdrücken finden Sie unter .NET Framework reguläre Ausdrücke und Sprache für reguläre Ausdrücke-kurzÜbersicht.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Die Suche nach Übereinstimmungen beginnt am Anfang der input Zeichenfolge.The search for matches starts at the beginning of the input string.

Der replacement -Parameter gibt die Zeichenfolge an, in inputder die einzelnen Treffer ersetzt werden sollen.The replacement parameter specifies the string that is to replace each match in input. replacementkann aus einer beliebigen Kombination aus Literaltext und Substitutionenbestehen.replacement can consist of any combination of literal text and substitutions. Das Ersetzungs Muster a*${test}b fügt z. b. die Zeichenfolge "a *" gefolgt von der Teil Zeichenfolge test , die mit der Erfassungs Gruppe übereinstimmt, ggf. gefolgt von der Zeichenfolge "b" ein.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Das Zeichen "*" wird nicht als Metazeichen innerhalb eines Ersetzungs Musters erkannt.The * character is not recognized as a metacharacter within a replacement pattern.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungs Muster erkannt werden.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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 nicht in Ersetzungs Mustern erkannt.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das Timeout Intervall überschreitet, das für die Anwendungsdomäne festgelegt wurde, in der die-Methode aufgerufen wird.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Wenn kein Timeout in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Hinweise für Aufrufer

Bei dieser Methode wird nach einem Intervall, das gleich dem Standard Timeout Wert der Anwendungsdomäne ist, in der Sie aufgerufen wird, ein Timeout festgestellt.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Wenn für die Anwendungsdomäne kein Timeout Wert definiert wurde, wird der Wert InfiniteMatchTimeoutverwendet, der das Timeout der Methode verhindert.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. Die empfohlene statische Methode zum Ersetzen einer Muster Übereinstimmung ist Replace(String, String, String, RegexOptions, TimeSpan), mit der Sie das Timeout Intervall festlegen können.The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Siehe auch

Replace(String, String, Int32) Replace(String, String, Int32) Replace(String, String, Int32) Replace(String, String, Int32)

Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

replacement
String String String String

Die Ersatzzeichenfolge.The replacement string.

count
Int32 Int32 Int32 Int32

Die maximale Anzahl der Ersetzungen.The maximum number of times the replacement can occur.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. 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.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

input oder replacement ist null.input or replacement is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel werden die ersten fünf Vorkommen doppelter Zeichen durch ein einzelnes Zeichen ersetzt.The following example replaces the first five occurrences of duplicated characters with a single character. Das Muster (\w)\1 für reguläre Ausdrücke gleicht aufeinander folgende Vorkommen eines einzelnen Zeichens ab und weist das erste Vorkommen der ersten Erfassungs Gruppe zu.The regular expression pattern (\w)\1 matches consecutive occurrences of a single character and assigns the first occurrence to the first capturing group. Das Ersetzungs $1 Muster ersetzt die gesamte Übereinstimmung mit der ersten erfassten Gruppe.The replacement pattern $1 replaces the entire match with the first captured group.

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.The search for matches starts at the beginning of the input string. Der reguläre Ausdruck ist das Muster, das durch den-Konstruktor für das aktuelle Regex -Objekt definiert wird.The regular expression is the pattern that is defined by the constructor for the current Regex object. Wenn count negativ ist, werden die Ersetzungen bis zum Ende der Zeichenfolge fortgesetzt.If count is negative, replacements continue to the end of the string. Wenn count die Anzahl der Übereinstimmungen überschreitet, werden alle Übereinstimmungen ersetzt.If count exceeds the number of matches, all matches are replaced.

Der replacement -Parameter gibt die Zeichenfolge an, in inputder count die ersten Übereinstimmungen ersetzt werden sollen.The replacement parameter specifies the string that is to replace the first count matches in input. replacementkann aus einer beliebigen Kombination aus Literaltext und Substitutionenbestehen.replacement can consist of any combination of literal text and substitutions. Das Ersetzungs Muster a*${test}b fügt z. b. die Zeichenfolge "a *" gefolgt von der Teil Zeichenfolge test , die mit der Erfassungs Gruppe übereinstimmt, ggf. gefolgt von der Zeichenfolge "b" ein.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Das Zeichen "*" wird nicht als Metazeichen innerhalb eines Ersetzungs Musters erkannt.The * character is not recognized as a metacharacter within a replacement pattern.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungs Muster erkannt werden.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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 nicht in Ersetzungs Mustern erkannt.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan) -Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des-Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der Regex das-Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Siehe auch

Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator) Replace(String, MatchEvaluator)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit einem angegebenen regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.A custom method that examines each match and returns either the original matched string or a replacement string.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. 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.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

input oder evaluator ist null.input or evaluator is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Codebeispiel wird eine ursprüngliche Zeichenfolge angezeigt, die mit den einzelnen Wörtern in der ursprünglichen Zeichenfolge übereinstimmt, das erste Zeichen jeder Übereinstimmung in einen Großbuchstaben konvertiert und dann die konvertierte Zeichenfolge angezeigt.The following code example displays an original string, matches each word in the original string, converts the first character of each match to uppercase, then displays the converted string.

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, wenn eine der folgenden Bedingungen zutrifft, um eine Entsprechung für reguläre Ausdrücke zu ersetzen:The Regex.Replace(String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Die Ersetzungs Zeichenfolge kann nicht ohne weiteres durch ein Ersatz Muster für reguläre Ausdrücke angegeben werden.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Die Ersetzungs Zeichenfolge ergibt sich aus der Verarbeitung der übereinstimmenden Zeichenfolge.The replacement string results from some processing done on the matched string.

  • Die Ersetzungs Zeichenfolge führt zu einer bedingten Verarbeitung.The replacement string results from conditional processing.

Die-Methode entspricht dem Aufrufen der Regex.Matches(String) -Methode und dem Match übergeben der einzelnen Objekte MatchCollection in der zurück evaluator gegebenen Auflistung an den-Delegaten.The method is equivalent to calling the Regex.Matches(String) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

Der reguläre Ausdruck ist das Muster, das durch den Konstruktor für das Regex aktuelle-Objekt definiert wird.The regular expression is the pattern defined by the constructor for the current Regex object.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Die benutzerdefinierte Methode muss die folgende Signatur aufweisen, damit MatchEvaluator Sie dem Delegaten entspricht.The custom method must have the following signature to match the MatchEvaluator delegate.

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.Your custom method returns a string that replaces the matched input.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan) -Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des-Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der Regex das-Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Siehe auch

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Ersetzt in einer angegebenen Eingabezeichenfolge alle mit dem Muster für den regulären Ausdruck übereinstimmenden Zeichenfolgen durch eine angegebene Ersetzungszeichenfolge.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

replacement
String String String String

Die Ersatzzeichenfolge.The replacement string.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Die Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. 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.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

input oder replacement ist null.input or replacement is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck \s+definiert,, der mit einem oder mehreren Leerzeichen übereinstimmt.The following example defines a regular expression, \s+, that matches one or more white-space characters. Die Ersetzungs Zeichenfolge "" ersetzt Sie durch ein einzelnes Leerzeichen.The replacement string, " ", replaces them with a single space character.

using System;
using System.Text.RegularExpressions;

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

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

Im folgenden Beispiel wird ein regulärer Ausdruck (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?,, und ein Ersetzungs $2Muster definiert, das entweder ein führendes oder ein nach gestelltes Währungssymbol aus einem numerischen Wert entfernt.The following example defines a regular expression, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?, and a replacement pattern, $2, that removes either a leading or a trailing currency symbol from a numeric value.

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.The regular expression is interpreted as shown in the following table.

MusterPattern BeschreibungDescription
\p{Sc} Entsprechung für ein Währungssymbol.Match a currency symbol. {Sc}bezeichnet alle Zeichen, die ein Member des Unicode-Symbols und der Currency-Kategorie sind.{Sc} denotes any character that is a member of the Unicode Symbol, Currency category.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.Match zero or one white-space character.
(\p{Sc}\s?)? Entspricht keinem oder einem Vorkommen der Kombination eines Währungs Symbols, gefolgt von keinem oder einem Leerzeichen.Match zero or one occurrence of the combination of a currency symbol followed by zero or one white-space character. Dies ist die erste Erfassungsgruppe.This is the first capturing group.
\d+ Entsprechung für mindestens eine Dezimalstelle finden.Match one or more decimal digits.
\.? Entsprechung für NULL oder ein Vorkommen eines Zeitraums (als Dezimaltrennzeichen verwendet).Match zero or one occurrence of a period (used as a decimal separator character).
((?<=\.)\d+)? Wenn ein Punkt das vorherige Zeichen ist, finden Sie eine Entsprechung für eine oder mehrere Dezimalstellen.If a period is the previous character, match one or more decimal digits. Dieses Muster kann entweder NULL oder einmal abgeglichen werden.This pattern can be matched either zero or one time.
(\d+\.?((?<=\.)\d+)?) Entsprechung für das Muster von einer oder mehreren Dezimalziffern, gefolgt von einem optionalen Zeitraum und zusätzlichen Dezimalziffern.Match the pattern of one or more decimal digits followed by an optional period and additional decimal digits. Dies ist die zweite Erfassungsgruppe.This is the second capturing group. Der- Replace(String, String) Methodenaufrufe ersetzt die gesamte-Entsprechung durch den Wert dieser erfassten Gruppe.The call to the Replace(String, String) method replaces the entire match with the value of this captured group.
(?(1)|\s?\p{Sc})? Wenn die erste erfasste Gruppe vorhanden ist, wird eine leere Zeichenfolge gefunden.If the first captured group exists, match an empty string. Andernfalls entspricht NULL oder ein Leerzeichen, gefolgt von einem Währungssymbol.Otherwise, match zero or one white-space character followed by a currency symbol.

Hinweise

Die Suche nach Übereinstimmungen beginnt am Anfang der input Zeichenfolge.The search for matches starts at the beginning of the input string. Der reguläre Ausdruck ist das Muster, das durch den Konstruktor für das Regex aktuelle-Objekt definiert wird.The regular expression is the pattern defined by the constructor for the current Regex object.

Der replacement -Parameter gibt die Zeichenfolge an, in inputder die einzelnen Treffer ersetzt werden sollen.The replacement parameter specifies the string that is to replace each match in input. replacementkann aus einer beliebigen Kombination aus Literaltext und Substitutionenbestehen.replacement can consist of any combination of literal text and substitutions. Das Ersetzungs Muster a*${test}b fügt z. b. die Zeichenfolge "a *" gefolgt von der Teil Zeichenfolge test , die mit der Erfassungs Gruppe übereinstimmt, ggf. gefolgt von der Zeichenfolge "b" ein.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". Das Zeichen "*" wird nicht als Metazeichen innerhalb eines Ersetzungs Musters erkannt.The * character is not recognized as a metacharacter within a replacement pattern.

Hinweis

Ersetzungen sind die einzigen Sprachelemente für reguläre Ausdrücke, die in einem Ersetzungs Muster erkannt werden.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 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 nicht in Ersetzungs Mustern erkannt.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan) -Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des-Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der Regex das-Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Siehe auch

Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32) Replace(String, MatchEvaluator, Int32)

Ersetzt in einer angegebenen Eingabezeichenfolge eine angegebene Höchstanzahl von Zeichenfolgen, die mit dem Muster eines regulären Ausdrucks übereinstimmen, durch eine von einem MatchEvaluator-Delegaten zurückgegebene Zeichenfolge.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

Die nach einer Übereinstimmung zu durchsuchende Zeichenfolge.The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Eine benutzerdefinierte Methode, die jede Übereinstimmung überprüft und entweder die ursprüngliche entsprechende Zeichenfolge oder eine Ersatzzeichenfolge zurückgibt.A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32 Int32 Int32 Int32

Die maximale Anzahl der Ersetzungen.The maximum number of times the replacement will occur.

Gibt zurück

Eine neue, mit der Eingabezeichenfolge identische Zeichenfolge. Eine Ersetzungszeichenfolge ersetzt jedoch alle übereinstimmenden Zeichenfolgen.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. 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.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Ausnahmen

input oder evaluator ist null.input or evaluator is null.

Es ist ein Timeout aufgetreten.A time-out occurred. Weitere Informationen zu Timeouts finden Sie im Abschnitt „Hinweise“.For more information about time-outs, see the Remarks section.

Beispiele

Im folgenden Beispiel wird ein regulärer Ausdruck verwendet, um die Hälfte der Wörter in einer Liste absichtlich falsch zu benennen.The following example uses a regular expression to deliberately misspell half of the words in a list. Der reguläre Ausdruck \w*(ie|ei)\w* wird verwendet, um Wörter abzugleichen, die die Zeichen "IE" oder "Ei" enthalten.It uses the regular expression \w*(ie|ei)\w* to match words that include the characters "ie" or "ei". Sie übergibt die erste Hälfte der übereinstimmenden Wörter an ReverseLetter die-Methode, die wiederum die Replace(String, String, String, RegexOptions) -Methode verwendet, um "i" und "e" in der übereinstimmenden Zeichenfolge umzukehren.It passes the first half of the matching words to the ReverseLetter method, which, in turn, uses the Replace(String, String, String, RegexOptions) method to reverse "i" and "e" in the matched string. Die restlichen Wörter bleiben unverändert.The remaining words remain unchanged.

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:The regular expression \w*(ie|ei)\w* is defined as shown in the following table.

MusterPattern BeschreibungDescription
\w* Übereinstimmung mit keinem oder mehreren Wortzeichen.Match zero or more word characters.
(ie|ei) Entspricht "IE" oder "Ei".Match either "ie" or "ei".
\w* Übereinstimmung mit keinem oder mehreren Wortzeichen.Match zero or more word characters.

Das Muster ([ie])([ie]) für reguläre Ausdrücke in ReverseLetter der Methode stimmt mit dem ersten "i" oder "e" in der Diphthong "IE" oder "Ei" überein und weist den Buchstaben der ersten Erfassungs Gruppe zu.The regular expression pattern ([ie])([ie]) in the ReverseLetter method matches the first "i" or "e" in the diphthong "ie" or "ei" and assigns the letter to the first capturing group. Sie entspricht dem zweiten "i" oder "e" und weist den Buchstaben der zweiten Erfassungs Gruppe zu.It matches the second "i" or "e" and assigns the letter to the second capturing group. Die beiden Zeichen werden dann durch Aufrufen der Replace(String, String, String) -Methode mit dem Ersetzungs Muster $2$1umgekehrt.The two characters are then reversed by calling the Replace(String, String, String) method with the replacement pattern $2$1.

Hinweise

Die Regex.Replace(String, MatchEvaluator, Int32) -Methode ist nützlich, wenn eine der folgenden Bedingungen zutrifft, um eine Entsprechung für reguläre Ausdrücke zu ersetzen:The Regex.Replace(String, MatchEvaluator, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Die Ersetzungs Zeichenfolge kann nicht ohne weiteres durch ein Ersatz Muster für reguläre Ausdrücke angegeben werden.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Die Ersetzungs Zeichenfolge ergibt sich aus der Verarbeitung der übereinstimmenden Zeichenfolge.The replacement string results from some processing done on the matched string.

  • Die Ersetzungs Zeichenfolge führt zu einer bedingten Verarbeitung.The replacement string results from conditional processing.

Die-Methode entspricht dem Aufrufen der Regex.Matches(String) -Methode und dem übergeben count der ersten Match Objekte in MatchCollection der zurückgegebenen evaluator Auflistung an den-Delegaten.The method is equivalent to calling the Regex.Matches(String) method and passing the first countMatch objects in the returned MatchCollection collection to the evaluator delegate.

Der reguläre Ausdruck ist das Muster, das durch den Konstruktor für das Regex aktuelle-Objekt definiert wird.The regular expression is the pattern defined by the constructor for the current Regex object.

Der evaluator -Parameter ist der Delegat für eine benutzerdefinierte Methode, die Sie definieren und die jede Übereinstimmung untersucht.The evaluator parameter is the delegate for a custom method that you define and that examines each match. Die benutzerdefinierte Methode muss die folgende Signatur aufweisen, damit MatchEvaluator Sie dem Delegaten entspricht.The custom method must have the following signature to match the MatchEvaluator delegate.

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.Your custom method returns a string that replaces the matched input.

Die RegexMatchTimeoutException -Ausnahme wird ausgelöst, wenn die Ausführungszeit des Ersetzungs Vorgangs das durch den Regex.Regex(String, RegexOptions, TimeSpan) -Konstruktor angegebene Timeout Intervall überschreitet.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Wenn Sie beim Aufruf des-Konstruktors kein Timeout Intervall festlegen, wird die Ausnahme ausgelöst, wenn der Vorgang einen Timeout Wert überschreitet, der für die Anwendungsdomäne festgelegt wurde, in der Regex das-Objekt erstellt wird.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Wenn kein Timeout im Regex Konstruktoraufruf oder in den Eigenschaften der Anwendungsdomäne definiert ist, oder wenn der Timeout Wert ist Regex.InfiniteMatchTimeout, wird keine Ausnahme ausgelöst.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Da die Methode unverändert input zurückgibt, wenn keine Entsprechung vorhanden ist, können Object.ReferenceEquals Sie die-Methode verwenden, um zu bestimmen, ob die Methode eine Ersetzung an der Eingabe Zeichenfolge vorgenommen hat.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Siehe auch

Gilt für: