Regex.Replace Methode

Definitie

Naamruimte:: System.Text.RegularExpressions

Assembly's:: System.dll, System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: System.Text.RegularExpressions.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

In een opgegeven invoertekenreeks vervangt u tekenreeksen die overeenkomen met een normaal expressiepatroon door een opgegeven vervangende tekenreeks.

Overloads

Name	Description
Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)	In een opgegeven invoertekenreeks vervangt u alle subtekenreeksen die overeenkomen met een opgegeven reguliere expressie door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde. Aanvullende parameters geven opties op waarmee de overeenkomende bewerking en een time-outinterval worden gewijzigd als er geen overeenkomst wordt gevonden.
Replace(String, String, String, RegexOptions, TimeSpan)	In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie met een opgegeven vervangende tekenreeks. Aanvullende parameters geven opties op waarmee de overeenkomende bewerking en een time-outinterval worden gewijzigd als er geen overeenkomst wordt gevonden.
Replace(String, MatchEvaluator, Int32, Int32)	In een opgegeven invoersubtekenreeks vervangt u een opgegeven maximum aantal tekenreeksen dat overeenkomt met een normaal expressiepatroon door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde.
Replace(String, String, MatchEvaluator, RegexOptions)	In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde. Opgegeven opties wijzigen de overeenkomende bewerking.
Replace(String, String, Int32, Int32)	In een opgegeven invoersubtekenreeks vervangt u een opgegeven maximum aantal tekenreeksen dat overeenkomt met een normaal expressiepatroon met een opgegeven vervangende tekenreeks.
Replace(String, String, String, RegexOptions)	In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie met een opgegeven vervangende tekenreeks. Opgegeven opties wijzigen de overeenkomende bewerking.
Replace(String, String, MatchEvaluator)	In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde.
Replace(String, String, String)	In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie met een opgegeven vervangende tekenreeks.
Replace(String, String, Int32)	In een opgegeven invoertekenreeks vervangt u een opgegeven maximum aantal tekenreeksen dat overeenkomt met een normaal expressiepatroon met een opgegeven vervangende tekenreeks.
Replace(String, MatchEvaluator)	In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde.
Replace(String, String)	In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een normaal expressiepatroon met een opgegeven vervangende tekenreeks.
Replace(String, MatchEvaluator, Int32)	In een opgegeven invoertekenreeks vervangt u een opgegeven maximum aantal tekenreeksen dat overeenkomt met een normaal expressiepatroon door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde.

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

In een opgegeven invoertekenreeks vervangt u alle subtekenreeksen die overeenkomen met een opgegeven reguliere expressie door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde. Aanvullende parameters geven opties op waarmee de overeenkomende bewerking en een time-outinterval worden gewijzigd als er geen overeenkomst wordt gevonden.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

pattern: String

Het reguliere expressiepatroon dat moet overeenkomen.

evaluator: MatchEvaluator

Een aangepaste methode die elke overeenkomst onderzoekt en de oorspronkelijke overeenkomende tekenreeks of een vervangende tekenreeks retourneert.

options: RegexOptions

Een bitsgewijze combinatie van opsommingswaarden die opties bieden voor overeenkomende waarden.

matchTimeout: TimeSpan

Een time-outinterval of InfiniteMatchTimeout om aan te geven dat er geen time-out optreedt voor de methode.

Retouren

String

Een nieuwe tekenreeks die identiek is aan de invoertekenreeks, behalve dat de vervangende tekenreeks de plaats krijgt van elke overeenkomende tekenreeks. Als pattern deze niet overeenkomt in het huidige exemplaar, retourneert de methode het huidige exemplaar ongewijzigd.

Uitzonderingen

ArgumentException

Er is een reguliere expressieparseringsfout opgetreden.

ArgumentNullException

input, patternof evaluator is null.

ArgumentOutOfRangeException

options is geen geldige bitsgewijze combinatie van RegexOptions waarden.

– of –

matchTimeout is negatief, nul of groter dan ongeveer 24 dagen.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende voorbeeld wordt een reguliere expressie gebruikt om de afzonderlijke woorden uit een tekenreeks te extraheren en vervolgens een gemachtigde gebruikt om een MatchEvaluator methode aan te roepen die WordScramble de afzonderlijke letters in het woord vervormt. Hiervoor maakt de WordScramble methode een matrix die de tekens in de overeenkomst bevat. Er wordt ook een parallelle matrix gemaakt die wordt gevuld met willekeurige drijvendekommanummers. De matrices worden gesorteerd door de Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) methode aan te roepen en de gesorteerde matrix wordt geleverd als argument voor een String klasseconstructor. Deze zojuist gemaakte tekenreeks wordt vervolgens geretourneerd door de WordScramble methode. Het reguliere expressiepatroon \w+ komt overeen met een of meer woordtekens. De engine voor reguliere expressies blijft tekens toevoegen aan de overeenkomst totdat er een niet-woordteken wordt weergegeven, zoals een spatieteken. De aanroep van de Replace(String, String, MatchEvaluator, RegexOptions) methode bevat de RegexOptions.IgnorePatternWhitespace optie, zodat de opmerking in het reguliere expressiepatroon \w+ # Matches all the characters in a word. wordt genegeerd door de engine voor reguliere expressies.

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

Opmerkingen

De Regex.Replace(String, String, MatchEvaluator, RegexOptions) methode is handig voor het vervangen van een reguliere expressie als aan een van de volgende voorwaarden wordt voldaan:

Als de vervangende tekenreeks niet gemakkelijk kan worden opgegeven door een normaal expressievervangingspatroon.
Als de vervangende tekenreeks het resultaat is van een bepaalde verwerking die wordt uitgevoerd op de overeenkomende tekenreeks.
Als de vervangende tekenreeks het resultaat is van voorwaardelijke verwerking.

De methode is gelijk aan het aanroepen van de Regex.Matches(String, String, RegexOptions) methode en het doorgeven van elk Match object in de geretourneerde MatchCollection verzameling aan de evaluator gedelegeerde.

De evaluator parameter is de gemachtigde voor een aangepaste methode die u definieert en die elke overeenkomst onderzoekt. De aangepaste methode moet de volgende handtekening hebben om overeen te komen met de MatchEvaluator gemachtigde.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

De aangepaste methode retourneert een tekenreeks die de overeenkomende invoer vervangt.

Als u opgeeft RightToLeft voor de options parameter, begint de zoekopdracht naar overeenkomsten aan het einde van de invoertekenreeks en gaat deze naar links. Anders begint de zoekopdracht aan het begin van de invoertekenreeks en gaat deze naar rechts.

De matchTimeout parameter geeft aan hoe lang een patroonkoppelingsmethode moet proberen een overeenkomst te vinden voordat er een time-out optreedt. Als u een time-outinterval instelt, voorkomt u dat reguliere expressies die afhankelijk zijn van overmatige backtracking niet meer reageren wanneer ze invoer verwerken die bijna overeenkomen. Zie Aanbevolen procedures voor reguliere expressies en backtracking voor meer informatie. Als er in dat tijdsinterval geen overeenkomst wordt gevonden, genereert de methode een RegexMatchTimeoutException uitzondering. matchTimeout overschrijft een standaardtime-outwaarde die is gedefinieerd voor het toepassingsdomein waarin de methode wordt uitgevoerd.

Omdat de methode ongewijzigd retourneert input als er geen overeenkomst is, kunt u de Object.ReferenceEquals methode gebruiken om te bepalen of de methode vervangingen heeft aangebracht in de invoertekenreeks.

Notities voor bellers

U wordt aangeraden de matchTimeout parameter in te stellen op een geschikte waarde, zoals twee seconden. Als u time-outs uitschakelt door op te InfiniteMatchTimeoutgeven, biedt de reguliere expressie-engine iets betere prestaties. Schakel echter alleen time-outs uit onder de volgende voorwaarden:

Wanneer de invoer die door een reguliere expressie wordt verwerkt, wordt afgeleid van een bekende en vertrouwde bron of bestaat uit statische tekst. Dit sluit tekst uit die dynamisch door gebruikers is ingevoerd.
Wanneer het reguliere expressiepatroon grondig is getest om ervoor te zorgen dat er efficiënt overeenkomsten, niet-overeenkomsten en bijna-overeenkomsten worden verwerkt.
Wanneer het reguliere expressiepatroon geen taalelementen bevat die bekend zijn dat ze overmatige backtracking veroorzaken bij het verwerken van een bijna-overeenkomst.

Zie ook

Van toepassing op

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

In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie met een opgegeven vervangende tekenreeks. Aanvullende parameters geven opties op waarmee de overeenkomende bewerking en een time-outinterval worden gewijzigd als er geen overeenkomst wordt gevonden.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

pattern: String

Het reguliere expressiepatroon dat moet overeenkomen.

replacement: String

De vervangende tekenreeks.

options: RegexOptions

Een bitsgewijze combinatie van de opsommingswaarden die opties bieden voor overeenkomende waarden.

matchTimeout: TimeSpan

Een time-outinterval of InfiniteMatchTimeout om aan te geven dat er geen time-out optreedt voor de methode.

Retouren

String

Uitzonderingen

ArgumentException

Er is een reguliere expressieparseringsfout opgetreden.

ArgumentNullException

input, patternof replacement is null.

ArgumentOutOfRangeException

options is geen geldige bitsgewijze combinatie van RegexOptions waarden.

– of –

matchTimeout is negatief, nul of groter dan ongeveer 24 dagen.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende voorbeeld wordt de Replace(String, String, String, RegexOptions, TimeSpan) methode gebruikt om de namen van de lokale computer en stations in een UNC-pad te vervangen door een lokaal bestandspad. De reguliere expressie gebruikt de Environment.MachineName eigenschap om de naam van de lokale computer en de Environment.GetLogicalDrives methode op te nemen van de namen van de logische stations. Alle vergelijkingen van reguliere expressietekenreeksen zijn hoofdlettergevoelig en er treedt een time-out op voor een enkele vervangingsbewerking als een overeenkomst niet in 0,5 seconde kan worden gevonden. Als u het voorbeeld wilt uitvoeren, moet u de letterlijke tekenreeks 'MyMachine' vervangen door de naam van uw lokale computer.

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

Het reguliere expressiepatroon wordt gedefinieerd door de volgende expressie:

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

In de volgende tabel ziet u hoe het reguliere expressiepatroon wordt geïnterpreteerd.

Patroon	Description
`\\\\`	Overeenkomen met twee opeenvolgende backslashtekens (`\`). Omdat het backslash-teken wordt geïnterpreteerd als het escape-teken, moet elke backslash worden escaped met een andere backslash.
`+ Environment.MachineName +`	Komt overeen met de tekenreeks die wordt geretourneerd door de Environment.MachineName eigenschap.
`(?:\.\w+)*`	Komt overeen met het puntteken (`.`) gevolgd door een of meer woordtekens. Deze overeenkomst kan nul of meer keren voorkomen. De overeenkomende subexpressie wordt niet vastgelegd.
`\\`	Kom overeen met een backslash (`\`) teken.
`([" + driveNames + "])`	Komt overeen met de tekenklasse die uit de afzonderlijke stationsletters bestaat. Deze overeenkomst is de eerste vastgelegde subexpressie.
`\$`	Komt overeen met het letterlijke dollarteken (`$`) teken.

Het vervangende patroon $1 vervangt de volledige overeenkomst door de eerste vastgelegde subexpressie. Dat wil gezegd, het vervangt de UNC-machine en stationnaam door de stationsletter.

Opmerkingen

De statische Replace methoden zijn gelijk aan het maken van een Regex object met het opgegeven reguliere expressiepatroon en het aanroepen van de instantiemethode Replace.

De pattern parameter bestaat uit reguliere expressietaalelementen die de tekenreeks symbolisch beschrijven die overeenkomen. Zie .NET Reguliere expressies en Regular Expression Language - Quick Reference voor meer informatie over reguliere expressies. Als u opgeeft RightToLeft voor de options parameter, begint de zoekopdracht naar overeenkomsten aan het einde van de invoertekenreeks en gaat deze naar links. Anders begint de zoekopdracht aan het begin van de invoertekenreeks en gaat deze naar rechts.

Met replacement de parameter wordt de tekenreeks opgegeven die elke overeenkomst in inputvervangt. replacement kan bestaan uit een combinatie van letterlijke tekst en vervangingen. Met het vervangende patroon a*${test}b wordt bijvoorbeeld de tekenreeks 'a*' ingevoegd, gevolgd door de subtekenreeks die overeenkomt met de test vastleggende groep, indien van toepassing, gevolgd door de tekenreeks 'b'. Het teken * wordt niet herkend als metacharacter binnen een vervangend patroon.

Note

Vervangingen zijn de enige reguliere expressietaalelementen die worden herkend in een vervangend patroon. Alle andere reguliere expressietaalelementen, waaronder escapes voor tekens, zijn alleen toegestaan in reguliere expressiepatronen en worden niet herkend in vervangingspatronen.

De matchTimeout parameter geeft aan hoe lang een patroonkoppelingsmethode moet proberen een overeenkomst te vinden voordat er een time-out optreedt. Als u een time-outinterval instelt, voorkomt u dat reguliere expressies die afhankelijk zijn van overmatige backtracking niet meer reageren wanneer ze invoer verwerken die bijna overeenkomsten bevat. Zie Aanbevolen procedures voor reguliere expressies en backtracking voor meer informatie. Als er in dat tijdsinterval geen overeenkomst wordt gevonden, genereert de methode een RegexMatchTimeoutException uitzondering. matchTimeout overschrijft een standaardtime-outwaarde die is gedefinieerd voor het toepassingsdomein waarin de methode wordt uitgevoerd.

Notities voor bellers

Wanneer de invoer die door een reguliere expressie wordt verwerkt, wordt afgeleid van een bekende en vertrouwde bron of bestaat uit statische tekst. Dit sluit tekst uit die dynamisch door gebruikers is ingevoerd.
Wanneer het reguliere expressiepatroon grondig is getest om ervoor te zorgen dat er efficiënt overeenkomsten, niet-overeenkomsten en bijna-overeenkomsten worden verwerkt.
Wanneer het reguliere expressiepatroon geen taalelementen bevat die bekend zijn dat ze overmatige backtracking veroorzaken bij het verwerken van een bijna-overeenkomst.

Zie ook

Van toepassing op

Replace(String, MatchEvaluator, Int32, Int32)

In een opgegeven invoersubtekenreeks vervangt u een opgegeven maximum aantal tekenreeksen dat overeenkomt met een normaal expressiepatroon door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

evaluator: MatchEvaluator

Een aangepaste methode die elke overeenkomst onderzoekt en de oorspronkelijke overeenkomende tekenreeks of een vervangende tekenreeks retourneert.

count: Int32

Het maximum aantal keren dat de vervanging plaatsvindt.

startat: Int32

De tekenpositie in de invoertekenreeks waar de zoekopdracht begint.

Retouren

String

Een nieuwe tekenreeks die identiek is aan de invoertekenreeks, behalve dat een vervangende tekenreeks de plaats van elke overeenkomende tekenreeks krijgt. Als het reguliere expressiepatroon niet overeenkomt in het huidige exemplaar, retourneert de methode het huidige exemplaar ongewijzigd.

Uitzonderingen

ArgumentNullException

input of evaluator is null.

ArgumentOutOfRangeException

startat is kleiner dan nul of groter dan de lengte van input.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Opmerkingen

De Regex.Replace(String, MatchEvaluator, Int32, Int32) methode is handig voor het vervangen van een reguliere expressie als aan een van de volgende voorwaarden wordt voldaan:

De vervangende tekenreeks kan niet gemakkelijk worden opgegeven door een normaal patroon voor expressievervanging.
De vervangende tekenreeks resulteert in een verwerking die is uitgevoerd op de overeenkomende tekenreeks.
De vervangende tekenreeks resulteert in voorwaardelijke verwerking.

De methode is gelijk aan het aanroepen van de Regex.Matches(String, Int32) methode en het doorgeven van de eersteMatchcountobjecten in de geretourneerde MatchCollection verzameling aan de evaluator gedelegeerde.

startatZie de sectie Opmerkingen van Match(String, Int32).

De reguliere expressie is het patroon dat is gedefinieerd door de constructor voor het huidige Regex object.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

De aangepaste methode retourneert een tekenreeks die de overeenkomende invoer vervangt.

De RegexMatchTimeoutException uitzondering wordt gegenereerd als de uitvoeringstijd van de vervangingsbewerking groter is dan het time-outinterval dat is opgegeven door de Regex.Regex(String, RegexOptions, TimeSpan) constructor. Als u geen time-outinterval instelt wanneer u de constructor aanroept, wordt de uitzondering gegenereerd als de bewerking een time-outwaarde overschrijdt die is ingesteld voor het toepassingsdomein waarin het Regex-object wordt gemaakt. Als er geen time-out is gedefinieerd in de Regex constructor-aanroep of in de eigenschappen van het toepassingsdomein, of als de time-outwaarde is Regex.InfiniteMatchTimeout, wordt er geen uitzondering gegenereerd

Zie ook

Van toepassing op

Replace(String, String, MatchEvaluator, RegexOptions)

In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde. Opgegeven opties wijzigen de overeenkomende bewerking.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

pattern: String

Het reguliere expressiepatroon dat moet overeenkomen.

evaluator: MatchEvaluator

Een aangepaste methode die elke overeenkomst onderzoekt en de oorspronkelijke overeenkomende tekenreeks of een vervangende tekenreeks retourneert.

options: RegexOptions

Een bitsgewijze combinatie van de opsommingswaarden die opties bieden voor overeenkomende waarden.

Retouren

String

Een nieuwe tekenreeks die identiek is aan de invoertekenreeks, behalve dat een vervangende tekenreeks de plaats van elke overeenkomende tekenreeks krijgt. Als pattern deze niet overeenkomt in het huidige exemplaar, retourneert de methode het huidige exemplaar ongewijzigd.

Uitzonderingen

ArgumentException

Er is een reguliere expressieparseringsfout opgetreden.

ArgumentNullException

input, patternof evaluator is null.

ArgumentOutOfRangeException

options is geen geldige bitsgewijze combinatie van RegexOptions waarden.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

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

Opmerkingen

De Regex.Replace(String, String, MatchEvaluator, RegexOptions) methode is handig voor het vervangen van een reguliere expressieovereenkomst als aan een van de volgende voorwaarden wordt voldaan:

De vervangende tekenreeks kan niet gemakkelijk worden opgegeven door een normaal patroon voor expressievervanging.
De vervangende tekenreeks resulteert in een verwerking die is uitgevoerd op de overeenkomende tekenreeks.
De vervangende tekenreeks resulteert in voorwaardelijke verwerking.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

De aangepaste methode retourneert een tekenreeks die de overeenkomende invoer vervangt.

De RegexMatchTimeoutException uitzondering wordt gegenereerd als de uitvoeringstijd van de vervangingsbewerking de time-outinterval overschrijdt die is opgegeven voor het toepassingsdomein waarin de methode wordt aangeroepen. Als er geen time-out is gedefinieerd in de eigenschappen van het toepassingsdomein of als de time-outwaarde is Regex.InfiniteMatchTimeout, wordt er geen uitzondering gegenereerd.

Zie ook

Van toepassing op

Replace(String, String, Int32, Int32)

In een opgegeven invoersubtekenreeks vervangt u een opgegeven maximum aantal tekenreeksen dat overeenkomt met een normaal expressiepatroon met een opgegeven vervangende tekenreeks.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

replacement: String

De vervangende tekenreeks.

count: Int32

Maximum aantal keren dat de vervanging kan optreden.

startat: Int32

De tekenpositie in de invoertekenreeks waar de zoekopdracht begint.

Retouren

String

Een nieuwe tekenreeks die identiek is aan de invoertekenreeks, behalve dat de vervangende tekenreeks de plaats krijgt van elke overeenkomende tekenreeks. Als het reguliere expressiepatroon niet overeenkomt in het huidige exemplaar, retourneert de methode het huidige exemplaar ongewijzigd.

Uitzonderingen

ArgumentNullException

input of replacement is null.

ArgumentOutOfRangeException

startat is kleiner dan nul of groter dan de lengte van input.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende voorbeeld worden alle dubbele spaties weergegeven, behalve de eerste regel van een tekenreeks. Het definieert een patroon voor een reguliere expressie, ^.*$dat overeenkomt met een tekstregel, roept de Match(String) methode aan om overeen te komen met de eerste regel van de tekenreeks en gebruikt de Match.Index en Match.Count eigenschappen om de beginpositie van de tweede regel te bepalen.

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.

Het reguliere expressiepatroon ^.*$ wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon	Description
`^`	Komt overeen met het begin van een regel. (Houd er rekening mee dat het Regex object is geïnstantieerd met behulp van de RegexOptions.Multiline optie. Anders komt deze tekenklasse alleen overeen met het begin van de invoertekenreeks.)
`.*`	Kom overeen met een willekeurig teken nul of meer keer.
`$`	Komt overeen met het einde van een regel. (Houd er rekening mee dat het Regex object is geïnstantieerd met behulp van de RegexOptions.Multiline optie. Anders komt deze tekenklasse alleen overeen met het begin van de invoertekenreeks.)

Met de vervangende tekenreeks (vbCrLf + "$&" in Visual Basic voegt "\n$&" in C#) een nieuwe regel toe vóór de overeenkomende tekenreeks. Houd er rekening mee dat \n in het C#-voorbeeld wordt geïnterpreteerd als het nieuwe regelteken door de C#-compiler; het vertegenwoordigt geen escape voor een reguliere expressieteken.

Opmerkingen

De zoekopdracht naar overeenkomsten begint in de input tekenreeks op de positie die is opgegeven door de startat parameter. De reguliere expressie is het patroon dat is gedefinieerd door de constructor voor het huidige Regex object. Als count dit negatief is, blijven vervangingen doorgaan naar het einde van de tekenreeks. Als count het aantal overeenkomsten wordt overschreden, worden alle overeenkomsten vervangen.

startatZie de sectie Opmerkingen van Match(String, Int32).

Note

Zie ook

Van toepassing op

Replace(String, String, String, RegexOptions)

In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie met een opgegeven vervangende tekenreeks. Opgegeven opties wijzigen de overeenkomende bewerking.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

pattern: String

Het reguliere expressiepatroon dat moet overeenkomen.

replacement: String

De vervangende tekenreeks.

options: RegexOptions

Een bitsgewijze combinatie van de opsommingswaarden die opties bieden voor overeenkomende waarden.

Retouren

String

Uitzonderingen

ArgumentException

Er is een reguliere expressieparseringsfout opgetreden.

ArgumentNullException

input, patternof replacement is null.

ArgumentOutOfRangeException

options is geen geldige bitsgewijze combinatie van RegexOptions waarden.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende voorbeeld wordt de Replace(String, String, String, RegexOptions) methode gebruikt om de namen van de lokale computer en stations in een UNC-pad te vervangen door een lokaal bestandspad. De reguliere expressie gebruikt de Environment.MachineName eigenschap om de naam van de lokale computer op te nemen en de Environment.GetLogicalDrives methode om de namen van de logische stations op te nemen. Alle reguliere expressiereeksvergelijkingen zijn hoofdlettergevoelig. Als u het voorbeeld wilt uitvoeren, moet u de letterlijke tekenreeks 'MyMachine' vervangen door de naam van uw lokale computer.

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

Het reguliere expressiepatroon wordt gedefinieerd door de volgende expressie:

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

In de volgende tabel ziet u hoe het reguliere expressiepatroon wordt geïnterpreteerd.

Patroon	Description
`\\\\`	Overeenkomen met twee opeenvolgende backslashtekens (`\`). Omdat het backslash-teken wordt geïnterpreteerd als het escape-teken, moet elke backslash worden escaped met een andere backslash.
`+ Environment.MachineName +`	Komt overeen met de tekenreeks die wordt geretourneerd door de Environment.MachineName eigenschap.
`(?:\.\w+)*`	Komt overeen met het puntteken (`.`) gevolgd door een of meer woordtekens. Deze overeenkomst kan nul of meer keren voorkomen. De overeenkomende subexpressie wordt niet vastgelegd.
`\\`	Kom overeen met een backslash (`\`) teken.
`([" + driveNames + "])`	Komt overeen met de tekenklasse die uit de afzonderlijke stationsletters bestaat. Deze overeenkomst is de eerste vastgelegde subexpressie.
`\$`	Komt overeen met het letterlijke dollarteken (`$`) teken.

Het vervangende patroon $1 vervangt de volledige overeenkomst door de eerste vastgelegde subexpressie. Dat wil gezegd, het vervangt de UNC-machine en stationnaam door de stationsletter.

Opmerkingen

De statische Replace methoden zijn gelijk aan het maken van een Regex object met het opgegeven reguliere expressiepatroon en het aanroepen van de instantiemethode Replace.

Note

Notities voor bellers

Deze methode treedt op na een interval dat gelijk is aan de standaardtime-outwaarde van het toepassingsdomein waarin deze wordt aangeroepen. Als er geen time-outwaarde is gedefinieerd voor het toepassingsdomein, wordt de waarde InfiniteMatchTimeout, waardoor er geen time-out optreedt voor de methode, gebruikt. De aanbevolen statische methode voor het vervangen van een patroonovereenkomst is Replace(String, String, String, RegexOptions, TimeSpan), waarmee u het time-outinterval kunt instellen.

Zie ook

Van toepassing op

Replace(String, String, MatchEvaluator)

In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

pattern: String

Het reguliere expressiepatroon dat moet overeenkomen.

evaluator: MatchEvaluator

Een aangepaste methode die elke overeenkomst onderzoekt en de oorspronkelijke overeenkomende tekenreeks of een vervangende tekenreeks retourneert.

Retouren

String

Uitzonderingen

ArgumentException

Er is een reguliere expressieparseringsfout opgetreden.

ArgumentNullException

input, patternof evaluator is null.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

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

Opmerkingen

De Regex.Replace(String, String, MatchEvaluator) methode is handig voor het vervangen van een reguliere expressie als aan een van de volgende voorwaarden wordt voldaan:

De vervangende tekenreeks kan niet gemakkelijk worden opgegeven door een normaal patroon voor expressievervanging.
De vervangende tekenreeks resulteert in een verwerking die is uitgevoerd op de overeenkomende tekenreeks.
De vervangende tekenreeks resulteert in voorwaardelijke verwerking.

De methode is gelijk aan het aanroepen van de Regex.Matches(String, String) methode en het doorgeven van elk Match object in de geretourneerde MatchCollection verzameling aan de evaluator gedelegeerde.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

De aangepaste methode retourneert een tekenreeks die de overeenkomende invoer vervangt.

Notities voor bellers

Deze methode treedt op na een interval dat gelijk is aan de standaardtime-outwaarde van het toepassingsdomein waarin deze wordt aangeroepen. Als er geen time-outwaarde is gedefinieerd voor het toepassingsdomein, wordt de waarde InfiniteMatchTimeout, waardoor er geen time-out optreedt voor de methode, gebruikt. De aanbevolen statische methode voor het evalueren en vervangen van een patroonovereenkomst is Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), waarmee u het time-outinterval kunt instellen.

Zie ook

Van toepassing op

Replace(String, String, String)

In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie met een opgegeven vervangende tekenreeks.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

pattern: String

Het reguliere expressiepatroon dat moet overeenkomen.

replacement: String

De vervangende tekenreeks.

Retouren

String

Uitzonderingen

ArgumentException

Er is een reguliere expressieparseringsfout opgetreden.

ArgumentNullException

input, patternof replacement is null.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende voorbeeld wordt een reguliere expressie gedefinieerd die \s+overeenkomt met een of meer spatietekens. De vervangende tekenreeks , " ", vervangt deze door één spatieteken.

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.

In het volgende voorbeeld wordt de Replace(String, String, String) methode gebruikt om de namen van de lokale computer en stations in een UNC-pad te vervangen door een lokaal bestandspad. De reguliere expressie gebruikt de Environment.MachineName eigenschap om de naam van de lokale computer op te nemen en de Environment.GetLogicalDrives methode om de namen van de logische stations op te nemen. Als u het voorbeeld wilt uitvoeren, moet u de letterlijke tekenreeks 'MyMachine' vervangen door de naam van uw lokale computer.

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

Het reguliere expressiepatroon wordt gedefinieerd door de volgende expressie:

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

In de volgende tabel ziet u hoe het reguliere expressiepatroon wordt geïnterpreteerd.

Patroon	Description
`\\\\`	Overeenkomen met twee opeenvolgende backslashtekens (`\`). Omdat het backslash-teken wordt geïnterpreteerd als het escape-teken, moet elke backslash worden escaped met een andere backslash.
`(?i:" + Environment.MachineName + ")`	Voer een niet-hoofdlettergevoelige overeenkomst uit van de tekenreeks die wordt geretourneerd door de Environment.MachineName eigenschap.
`(?:\.\w+)*`	Komt overeen met het puntteken (`.`) gevolgd door een of meer woordtekens. Deze overeenkomst kan nul of meer keren voorkomen. De overeenkomende subexpressie wordt niet vastgelegd.
`\\`	Kom overeen met een backslash (`\`) teken.
`((?i:[" + driveNames + "]))`	Voer een hoofdlettergevoelige overeenkomst uit van de tekenklasse die uit de afzonderlijke stationsletters bestaat. Deze overeenkomst is de eerste vastgelegde subexpressie.
`\$`	Komt overeen met het letterlijke dollarteken (`$`) teken.

Het vervangende patroon $1 vervangt de volledige overeenkomst door de eerste vastgelegde subexpressie. Dat wil gezegd, het vervangt de UNC-machine en stationnaam door de stationsletter.

Opmerkingen

De statische Replace methoden zijn gelijk aan het maken van een Regex object met het opgegeven reguliere expressiepatroon en het aanroepen van de instantiemethode Replace.

Note

Notities voor bellers

Zie ook

Van toepassing op

Replace(String, String, Int32)

In een opgegeven invoertekenreeks vervangt u een opgegeven maximum aantal tekenreeksen dat overeenkomt met een normaal expressiepatroon met een opgegeven vervangende tekenreeks.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

replacement: String

De vervangende tekenreeks.

count: Int32

Het maximum aantal keren dat de vervanging kan plaatsvinden.

Retouren

String

Uitzonderingen

ArgumentNullException

input of replacement is null.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende voorbeeld worden de eerste vijf exemplaren van dubbele tekens vervangen door één teken. Het reguliere expressiepatroon (\w)\1 komt overeen met opeenvolgende exemplaren van één teken en wijst het eerste exemplaar toe aan de eerste vastleggende groep. Het vervangende patroon $1 vervangt de volledige overeenkomst door de eerste vastgelegde groep.

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'

Opmerkingen

De zoekopdracht naar overeenkomsten begint aan het begin van de input tekenreeks. De reguliere expressie is het patroon dat wordt gedefinieerd door de constructor voor het huidige Regex object. Als count dit negatief is, blijven vervangingen doorgaan naar het einde van de tekenreeks. Als count het aantal overeenkomsten wordt overschreden, worden alle overeenkomsten vervangen.

Met replacement de parameter wordt de tekenreeks opgegeven die de eerste count overeenkomsten in inputvervangt. replacement kan bestaan uit een combinatie van letterlijke tekst en vervangingen. Met het vervangende patroon a*${test}b wordt bijvoorbeeld de tekenreeks 'a*' ingevoegd, gevolgd door de subtekenreeks die overeenkomt met de test vastleggende groep, indien van toepassing, gevolgd door de tekenreeks 'b'. Het teken * wordt niet herkend als metacharacter binnen een vervangend patroon.

Note

Zie ook

Van toepassing op

Replace(String, MatchEvaluator)

In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een opgegeven reguliere expressie door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

evaluator: MatchEvaluator

Een aangepaste methode die elke overeenkomst onderzoekt en de oorspronkelijke overeenkomende tekenreeks of een vervangende tekenreeks retourneert.

Retouren

String

Uitzonderingen

ArgumentNullException

input of evaluator is null.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende codevoorbeeld ziet u een oorspronkelijke tekenreeks, komt overeen met elk woord in de oorspronkelijke tekenreeks, wordt het eerste teken van elke overeenkomst geconverteerd naar hoofdletters en wordt vervolgens de geconverteerde tekenreeks weergegeven.

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]

Opmerkingen

De Regex.Replace(String, MatchEvaluator) methode is handig voor het vervangen van een reguliere expressie als aan een van de volgende voorwaarden wordt voldaan:

De vervangende tekenreeks kan niet gemakkelijk worden opgegeven door een normaal patroon voor expressievervanging.
De vervangende tekenreeks resulteert in een verwerking die is uitgevoerd op de overeenkomende tekenreeks.
De vervangende tekenreeks resulteert in voorwaardelijke verwerking.

De methode is gelijk aan het aanroepen van de Regex.Matches(String) methode en het doorgeven van elk Match object in de geretourneerde MatchCollection verzameling aan de evaluator gedelegeerde.

De reguliere expressie is het patroon dat is gedefinieerd door de constructor voor het huidige Regex object.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

De aangepaste methode retourneert een tekenreeks die de overeenkomende invoer vervangt.

Zie ook

Van toepassing op

Replace(String, String)

In een opgegeven invoertekenreeks vervangt u alle tekenreeksen die overeenkomen met een normaal expressiepatroon met een opgegeven vervangende tekenreeks.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

replacement: String

De vervangende tekenreeks.

Retouren

String

Uitzonderingen

ArgumentNullException

input of replacement is null.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende voorbeeld wordt een reguliere expressie gedefinieerd die \s+overeenkomt met een of meer spatietekens. De vervangende tekenreeks , " ", vervangt deze door één spatieteken.

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.

In het volgende voorbeeld wordt een reguliere expressie en (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?een vervangend patroon gedefinieerd, $2waarmee een voorloop- of volgvalutasymbool uit een numerieke waarde wordt verwijderd.

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'

De reguliere expressie wordt geïnterpreteerd zoals weergegeven in de volgende tabel.

Patroon	Description
`\p{Sc}`	Komt overeen met een valutasymbool. `{Sc}` geeft een teken aan dat lid is van de categorie Unicode-symbool, valuta.
`\s?`	Vind nul of één spatieteken.
`(\p{Sc}\s?)?`	Kom overeen met nul of één exemplaar van de combinatie van een valutasymbool, gevolgd door nul of één witruimteteken. Dit is de eerste capturegroep.
`\d+`	Vergelijk een of meer decimale cijfers.
`\.?`	Kom overeen met nul of één exemplaar van een punt (gebruikt als een decimaalteken).
`((?<=\.)\d+)?`	Als een punt het vorige teken is, komt u overeen met een of meer decimale cijfers. Dit patroon kan worden vergeleken met nul of één keer.
`(\d+\.?((?<=\.)\d+)?)`	Komt overeen met het patroon van een of meer decimale cijfers, gevolgd door een optionele punt en extra decimale cijfers. Dit is de tweede opslaggroep. De aanroep van de Replace(String, String) methode vervangt de volledige overeenkomst door de waarde van deze vastgelegde groep.
`(?(1)\|\s?\p{Sc})?`	Als de eerste vastgelegde groep bestaat, komt u overeen met een lege tekenreeks. Anders moet u nul of één witruimteteken vergelijken, gevolgd door een valutasymbool.

Opmerkingen

De zoekopdracht naar overeenkomsten begint aan het begin van de input tekenreeks. De reguliere expressie is het patroon dat is gedefinieerd door de constructor voor het huidige Regex object.

Note

Zie ook

Van toepassing op

Replace(String, MatchEvaluator, Int32)

In een opgegeven invoertekenreeks vervangt u een opgegeven maximum aantal tekenreeksen dat overeenkomt met een normaal expressiepatroon door een tekenreeks die wordt geretourneerd door een MatchEvaluator gemachtigde.

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

Parameters

input: String

De tekenreeks om naar een overeenkomst te zoeken.

evaluator: MatchEvaluator

Een aangepaste methode die elke overeenkomst onderzoekt en de oorspronkelijke overeenkomende tekenreeks of een vervangende tekenreeks retourneert.

count: Int32

Het maximum aantal keren dat de vervanging plaatsvindt.

Retouren

String

Uitzonderingen

ArgumentNullException

input of evaluator is null.

RegexMatchTimeoutException

Er is een time-out opgetreden. Zie de sectie Opmerkingen voor meer informatie over time-outs.

Voorbeelden

In het volgende voorbeeld wordt een reguliere expressie gebruikt om opzettelijk de helft van de woorden in een lijst verkeerd te spelen. De reguliere expressie \w*(ie|ei)\w* wordt gebruikt om woorden te vinden die de tekens 'ie' of 'ei' bevatten. De eerste helft van de overeenkomende woorden wordt doorgegeven aan de ReverseLetter methode, die op zijn beurt de Replace(String, String, String, RegexOptions) methode gebruikt om 'i' en 'e' om te keren in de overeenkomende tekenreeks. De resterende woorden blijven ongewijzigd.

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

De reguliere expressie \w*(ie|ei)\w* wordt gedefinieerd zoals wordt weergegeven in de volgende tabel.

Patroon	Description
`\w*`	Kom overeen met nul of meer woordtekens.
`(ie\|ei)`	Komt overeen met 'ie' of 'ei'.
`\w*`	Kom overeen met nul of meer woordtekens.

Het reguliere expressiepatroon ([ie])([ie]) in de ReverseLetter methode komt overeen met de eerste 'i' of 'e' in de diphthong 'ie' of 'ei' en wijst de letter toe aan de eerste vastleggende groep. Deze komt overeen met de tweede 'i' of 'e' en wijst de letter toe aan de tweede groep voor vastleggen. De twee tekens worden vervolgens omgekeerd door de Replace(String, String, String) methode aan te roepen met het vervangingspatroon $2$1.

Opmerkingen

De Regex.Replace(String, MatchEvaluator, Int32) methode is handig voor het vervangen van een reguliere expressie als aan een van de volgende voorwaarden wordt voldaan:

De vervangende tekenreeks kan niet gemakkelijk worden opgegeven door een normaal patroon voor expressievervanging.
De vervangende tekenreeks resulteert in een verwerking die is uitgevoerd op de overeenkomende tekenreeks.
De vervangende tekenreeks resulteert in voorwaardelijke verwerking.

De methode is gelijk aan het aanroepen van de Regex.Matches(String) methode en het doorgeven van de eersteMatchcountobjecten in de geretourneerde MatchCollection verzameling aan de evaluator gedelegeerde.

De reguliere expressie is het patroon dat is gedefinieerd door de constructor voor het huidige Regex object.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

De aangepaste methode retourneert een tekenreeks die de overeenkomende invoer vervangt.

Zie ook

Van toepassing op

Feedback

Is deze pagina nuttig?