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

Definition

Dans la chaîne d'entrée spécifiée, remplace les chaînes qui correspondent à un modèle d'expression régulière par une chaîne de remplacement spécifique. In a specified input string, replaces strings that match a regular expression pattern with a specified replacement string.

Overloads

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

Dans la chaîne d’entrée spécifiée, remplace toutes les sous-chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée. 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)

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée. 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)

Dans la sous-chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne retournée par un délégué MatchEvaluator. 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)

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Les options spécifiées modifient l'opération correspondante. 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)

Dans une sous-chaîne d’entrée spécifiée, remplace un nombre maximal spécifié de chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée. 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)

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Les options spécifiées modifient l'opération correspondante. Specified options modify the matching operation.

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

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. 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)

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée. 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)

Dans une chaîne d’entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée. 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)

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. 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)

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée. 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)

Dans la chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne retournée par un délégué MatchEvaluator. 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)

Dans la chaîne d’entrée spécifiée, remplace toutes les sous-chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance. The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement. A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance. A bitwise combination of enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer. A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si pattern n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite. A regular expression parsing error occurred.

input, pattern ou evaluator a la valeur null. input, pattern, or evaluator is null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions. options is not a valid bitwise combination of RegexOptions values. - ou - -or- matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours. matchTimeout is negative, zero, or greater than approximately 24 days.

Un dépassement du délai d’attente s’est produit. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant utilise une expression régulière pour extraire les mots individuels d’une chaîne, puis utilise un MatchEvaluator délégué à appeler une méthode nommée WordScramble qui brouille les lettres individuelles dans le mot.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. Pour ce faire, le WordScramble méthode crée un tableau qui contient les caractères dans la correspondance.To do this, the WordScramble method creates an array that contains the characters in the match. Il crée également un tableau parallèle qu’il remplit avec des nombres à virgule flottante aléatoire.It also creates a parallel array that it populates with random floating-point numbers. Les tableaux sont triés en appelant le Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) (méthode) et le tableau trié est fourni en tant qu’argument à un String constructeur de classe.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. Cette chaîne nouvellement créée est ensuite retournée par la WordScramble (méthode).This newly created string is then returned by the WordScramble method. Le modèle d’expression régulière \w+ correspond à un ou plusieurs caractères alphabétiques ; le moteur d’expression régulière continue à ajouter des caractères à la correspondance jusqu'à ce qu’il rencontre un caractère non alphabétique, par exemple un caractère d’espace blanc.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. L’appel à la Replace(String, String, MatchEvaluator, RegexOptions) méthode inclut la RegexOptions.IgnorePatternWhitespace option afin que le commentaire dans le modèle d’expression régulière \w+ # Matches all the characters in a word. est ignoré par le moteur d’expression régulière.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

Remarks

Le Regex.Replace(String, String, MatchEvaluator, RegexOptions) méthode est utile pour remplacer une correspondance d’expression régulière si une des conditions suivantes est vraie :The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Si la chaîne de remplacement ne peut pas être facilement spécifiée par un modèle de remplacement d’expression régulière.If the replacement string cannot readily be specified by a regular expression replacement pattern.

  • Si la chaîne de remplacement résulte d’un traitement est effectuée sur la chaîne correspondante.If the replacement string results from some processing performed on the matched string.

  • Si la chaîne de remplacement résulte de traitement conditionnel.If the replacement string results from conditional processing.

La méthode revient à appeler le Regex.Matches(String, String, RegexOptions) méthode et passer chaque Match objet retourné MatchCollection collection à la evaluator déléguer.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.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Le evaluator paramètre est le délégué d’une méthode personnalisée que vous définissez et qui examine chaque correspondance.The evaluator parameter is the delegate for a custom method that you define and that examines each match. La méthode personnalisée doit avoir la signature suivante pour faire correspondre le MatchEvaluator déléguer.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

Votre méthode personnalisée retourne une chaîne qui remplace l’entrée correspondante.Your custom method returns a string that replaces the matched input.

Si vous spécifiez RightToLeft pour le options de paramètre, la recherche de correspondances commence à la fin de la chaîne d’entrée et les déplace vers la gauche ; sinon, la recherche commence au début de la chaîne d’entrée et déplacé vers la droite.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.

Le matchTimeout paramètre spécifie la manière dont la durée pendant laquelle un modèle de correspondance méthode doit essayer de trouver une correspondance avant son expiration. Définition d’un intervalle de délai d’attente empêche des expressions régulières qui s’appuient sur une rétroaction excessive d’apparaître à « cesser de répondre lorsqu’elles traitent une entrée qui contient près de correspondances.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. Pour plus d’informations, consultez meilleures pratiques pour les Expressions régulières et rétroaction.For more information, see Best Practices for Regular Expressions and Backtracking. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève un RegexMatchTimeoutException exception.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout remplace toute valeur de délai d’attente par défaut défini pour le domaine d’application dans laquelle la méthode s’exécute.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

Notes to Callers

Nous vous recommandons de définir le matchTimeout paramètre à une valeur appropriée, comme les deux secondes. We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si vous désactivez des délais d’attente en spécifiant InfiniteMatchTimeout, le moteur d’expression régulière offre des performances légèrement meilleures. If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Toutefois, vous devez désactiver les délais d’attente uniquement dans les conditions suivantes : However, you should disable time-outs only under the following conditions: -Lorsque l’entrée traitée par une expression régulière est dérivée d’une source connue et approuvée ou se compose de texte statique. - When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Cela exclut le texte qui a été dynamiquement par les utilisateurs. This excludes text that has been dynamically input by users. -Lorsque le modèle d’expression régulière a été testé pour s’assurer qu’elle gère efficacement corresponde au, non-correspondances et proche. - When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches. -Lorsque le modèle d’expression régulière ne contient aucun élément de langage qui est connus pour provoquer une rétroaction excessive lors du traitement d’une correspondance proche. - When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

See Also

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

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Les paramètres supplémentaires spécifient les options qui modifient l'opération et l'intervalle de délai d'attente correspondants si aucune correspondance n'est trouvée. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance. The regular expression pattern to match.

replacement
String String String String

Chaîne de remplacement. The replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance. A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer. A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si pattern n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite. A regular expression parsing error occurred.

input, pattern ou replacement a la valeur null. input, pattern, or replacement is null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions. options is not a valid bitwise combination of RegexOptions values. - ou - -or- matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours. matchTimeout is negative, zero, or greater than approximately 24 days.

Un dépassement du délai d’attente s’est produit. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant utilise la Replace(String, String, String, RegexOptions, TimeSpan) méthode pour remplacer les noms d’ordinateur et le lecteur locales dans un chemin d’accès UNC avec un chemin d’accès de fichier local.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. L’expression régulière utilise la Environment.MachineName propriété à inclure le nom de l’ordinateur local et le Environment.GetLogicalDrives méthode pour inclure les noms des lecteurs logiques.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. Toutes les comparaisons de chaîne d’expression régulière respectent la casse, et toute opération de remplacement unique expire si une correspondance est introuvable dans 0,5 seconde.All regular expression string comparisons are case-insensitive, and any single replacement operation times out if a match cannot be found in 0.5 second. Pour exécuter l’exemple, vous devez remplacer la chaîne littérale « Monordinateur » par le nom de votre ordinateur local.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

Le modèle d’expression régulière est défini par l’expression suivante :The regular expression pattern is defined by the following expression:

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

Le tableau suivant montre comment le modèle d'expression régulière est interprété.The following table shows how the regular expression pattern is interpreted.

MotifPattern Description Description
\\\\ Barre oblique inverse consécutif de correspondance deux (\) caractères.Match two consecutive backslash (\) characters. Étant donné que le caractère barre oblique inverse est interprété comme caractère d’échappement, chaque barre oblique inverse doit être précédé d’une autre barre oblique inverse.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Correspond à la chaîne retournée par la Environment.MachineName propriété.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Correspond à la période (.) caractères suivi d’un ou plusieurs caractères alphabétiques.Match the period (.) character followed by one or more word characters. Cette correspondance peut se produire zéro ou plusieurs fois.This match can occur zero or more times. La sous-expression mise en correspondance n’est pas capturée.The matched subexpression is not captured.
\\ Correspond à une barre oblique inverse (\) caractères.Match a backslash (\) character.
([" + driveNames + "]) Correspond à la classe de caractères qui se compose de lettres de lecteur individuelles.Match the character class that consists of the individual drive letters. Cette correspondance est la première sous-expression capturée.This match is the first captured subexpression.
\$ Correspond au signe dollar littéral ($) caractères.Match the literal dollar sign ($) character.

Le modèle de remplacement $1 remplace la correspondance entière par la première sous-expression capturée.The replacement pattern $1 replaces the entire match with the first captured subexpression. Autrement dit, il remplace le nom d’ordinateur et le lecteur UNC par la lettre de lecteur.That is, it replaces the UNC machine and drive name with the drive letter.

Remarks

La méthode statique Replace méthodes sont équivalentes à construire un Regex de l’objet avec le modèle d’expression régulière spécifiée et en appelant la méthode d’instance Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Si vous spécifiez RightToLeft pour le options de paramètre, la recherche de correspondances commence à la fin de la chaîne d’entrée et les déplace vers la gauche ; sinon, la recherche commence au début de la chaîne d’entrée et déplacé vers la droite.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.

Le replacement paramètre spécifie la chaîne qui doit remplacer chaque correspondance dans input.The replacement parameter specifies the string that is to replace each match in input. replacement peut être constitué de n’importe quelle combinaison de texte littéral et substitutions.replacement can consist of any combination of literal text and substitutions. Par exemple, le modèle de remplacement a*${test}b insère la chaîne « un * » suivie de la sous-chaîne qui est mis en correspondance par le test groupe de capture, le cas échéant, suivie de la chaîne « b ».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". Le * caractère n’est pas reconnu comme un caractère de remplacement dans un modèle de remplacement.The * character is not recognized as a metacharacter within a replacement pattern.

Note

Les substitutions sont les éléments de langage d’expression régulière seulement sont reconnus dans un modèle de remplacement.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Tous les autres éléments de langage d’expression régulière, notamment caractère d’échappement, sont autorisées dans les modèles d’expressions régulières uniquement et ne sont pas reconnues dans les modèles de remplacement.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Le matchTimeout paramètre spécifie la manière dont la durée pendant laquelle un modèle de correspondance méthode doit essayer de trouver une correspondance avant son expiration. Définition d’un intervalle de délai d’attente empêche des expressions régulières qui s’appuient sur une rétroaction excessive d’apparaître à cesser de répondre lorsqu’elles traitent une entrée qui contient près de correspondances.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. Pour plus d’informations, consultez meilleures pratiques pour les Expressions régulières et rétroaction.For more information, see Best Practices for Regular Expressions and Backtracking. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève un RegexMatchTimeoutException exception.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout remplace toute valeur de délai d’attente par défaut défini pour le domaine d’application dans laquelle la méthode s’exécute.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

Notes to Callers

Nous vous recommandons de définir le matchTimeout paramètre à une valeur appropriée, comme les deux secondes. We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si vous désactivez des délais d’attente en spécifiant InfiniteMatchTimeout, le moteur d’expression régulière offre des performances légèrement meilleures. If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Toutefois, vous devez désactiver les délais d’attente uniquement dans les conditions suivantes : However, you should disable time-outs only under the following conditions: -Lorsque l’entrée traitée par une expression régulière est dérivée d’une source connue et approuvée ou se compose de texte statique. - When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Cela exclut le texte qui a été dynamiquement par les utilisateurs. This excludes text that has been dynamically input by users. -Lorsque le modèle d’expression régulière a été testé pour s’assurer qu’elle gère efficacement corresponde au, non-correspondances et proche. - When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches. -Lorsque le modèle d’expression régulière ne contient aucun élément de langage qui est connus pour provoquer une rétroaction excessive lors du traitement d’une correspondance proche. - When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

See Also

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

Dans la sous-chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne retournée par un délégué MatchEvaluator. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement. A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32 Int32 Int32 Int32

Nombre maximal de fois où le remplacement aura lieu. The maximum number of times the replacement will occur.

startat
Int32 Int32 Int32 Int32

Position du caractère dans la chaîne d’entrée où la recherche commence. The character position in the input string where the search begins.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf qu'une chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si le modèle d’expression régulière n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

input ou evaluator a la valeur null. input or evaluator is null.

startat est inférieur à zéro ou supérieur à la longueur de input. startat is less than zero or greater than the length of input.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Remarks

Le Regex.Replace(String, MatchEvaluator, Int32, Int32) méthode est utile pour remplacer une correspondance d’expression régulière si une des conditions suivantes est vraie :The Regex.Replace(String, MatchEvaluator, Int32, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Impossible de spécifier facilement la chaîne de remplacement par un modèle de remplacement d’expression régulière.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Résultats de la chaîne de remplacement d’un traitement effectué sur la chaîne correspondante.The replacement string results from some processing done on the matched string.

  • Résultats de la chaîne de remplacement d’un traitement conditionnel.The replacement string results from conditional processing.

La méthode revient à appeler le Regex.Matches(String, Int32) (méthode) et en passant la première count Match objets retourné MatchCollection collection à la evaluator déléguer.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.

L’expression régulière est le modèle défini par le constructeur pour actuel Regex objet.The regular expression is the pattern defined by the constructor for the current Regex object.

Le evaluator paramètre est le délégué d’une méthode personnalisée que vous définissez et qui examine chaque correspondance.The evaluator parameter is the delegate for a custom method that you define and that examines each match. La méthode personnalisée doit avoir la signature suivante pour faire correspondre le MatchEvaluator déléguer.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

Votre méthode personnalisée retourne une chaîne qui remplace l’entrée correspondante.Your custom method returns a string that replaces the matched input.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.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. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.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. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

See Also

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

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Les options spécifiées modifient l'opération correspondante. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance. The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement. A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance. A bitwise combination of the enumeration values that provide options for matching.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf qu'une chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si pattern n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite. A regular expression parsing error occurred.

input, pattern ou evaluator a la valeur null. input, pattern, or evaluator is null.

options n’est pas une combinaison valide au niveau du bit de valeurs RegexOptions. options is not a valid bitwise combination of RegexOptions values.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant utilise une expression régulière pour extraire les mots individuels d’une chaîne, puis utilise un MatchEvaluator délégué à appeler une méthode nommée WordScramble qui brouille les lettres individuelles dans le mot.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. Pour ce faire, le WordScramble méthode crée un tableau qui contient les caractères dans la correspondance.To do this, the WordScramble method creates an array that contains the characters in the match. Il crée également un tableau parallèle qu’il remplit avec des nombres à virgule flottante aléatoire.It also creates a parallel array that it populates with random floating-point numbers. Les tableaux sont triés en appelant le Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) (méthode) et le tableau trié est fourni en tant qu’argument à un String constructeur de classe.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. Cette chaîne nouvellement créée est ensuite retournée par la WordScramble (méthode).This newly created string is then returned by the WordScramble method. Le modèle d’expression régulière \w+ correspond à un ou plusieurs caractères alphabétiques ; le moteur d’expression régulière continue à ajouter des caractères à la correspondance jusqu'à ce qu’il rencontre un caractère non alphabétique, par exemple un caractère d’espace blanc.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. L’appel à la Replace(String, String, MatchEvaluator, RegexOptions) méthode inclut la RegexOptions.IgnorePatternWhitespace option afin que le commentaire dans le modèle d’expression régulière \w+ # Matches all the characters in a word. est ignoré par le moteur d’expression régulière.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

Remarks

Le Regex.Replace(String, String, MatchEvaluator, RegexOptions) méthode est utile pour remplacer une correspondance d’expression régulière si une des conditions suivantes est vraie :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:

  • Impossible de spécifier facilement la chaîne de remplacement par un modèle de remplacement d’expression régulière.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Résultats de la chaîne de remplacement d’un traitement effectué sur la chaîne correspondante.The replacement string results from some processing done on the matched string.

  • Résultats de la chaîne de remplacement d’un traitement conditionnel.The replacement string results from conditional processing.

La méthode revient à appeler le Regex.Matches(String, String, RegexOptions) méthode et passer chaque Match objet retourné MatchCollection collection à la evaluator déléguer.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.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Le evaluator paramètre est le délégué d’une méthode personnalisée que vous définissez et qui examine chaque correspondance.The evaluator parameter is the delegate for a custom method that you define and that examines each match. La méthode personnalisée doit avoir la signature suivante pour faire correspondre le MatchEvaluator déléguer.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

Votre méthode personnalisée retourne une chaîne qui remplace l’entrée correspondante.Your custom method returns a string that replaces the matched input.

Si vous spécifiez RightToLeft pour le options de paramètre, la recherche de correspondances commence à la fin de la chaîne d’entrée et les déplace vers la gauche ; sinon, la recherche commence au début de la chaîne d’entrée et déplacé vers la droite.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.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée.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. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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.

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

See Also

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

Dans une sous-chaîne d’entrée spécifiée, remplace un nombre maximal spécifié de chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

replacement
String String String String

Chaîne de remplacement. The replacement string.

count
Int32 Int32 Int32 Int32

Nombre maximal d’occurrences du remplacement. Maximum number of times the replacement can occur.

startat
Int32 Int32 Int32 Int32

Position du caractère dans la chaîne d’entrée où la recherche commence. The character position in the input string where the search begins.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si le modèle d’expression régulière n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

input ou replacement a la valeur null. input or replacement is null.

startat est inférieur à zéro ou supérieur à la longueur de input. startat is less than zero or greater than the length of input.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant applique un interligne double toutes les valeurs sauf la première ligne d’une chaîne.The following example double-spaces all but the first line of a string. Il définit un modèle d’expression régulière, ^.*$, qui correspond à une ligne de texte, appelle le Match(String) méthode pour faire correspondre la première ligne de la chaîne et utilise le Match.Index et Match.Count propriétés pour déterminer la position de départ de la seconde ligne.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.

Le modèle d'expression régulière ^.*$ est défini comme indiqué dans le tableau suivant.The regular expression pattern ^.*$ is defined as shown in the following table.

MotifPattern Description Description
^ Correspond au début d’une ligne.Match the start of a line. (Notez que le Regex objet a été instancié à l’aide de la RegexOptions.Multiline option ; sinon, cette classe de caractères correspondrait à uniquement le début de la chaîne d’entrée.)(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.)
.* Correspond à n’importe quel caractère zéro ou plusieurs fois.Match any character zero or more times.
$ Correspond à la fin d’une ligne.Match the end of a line. (Notez que le Regex objet a été instancié à l’aide de la RegexOptions.Multiline option ; sinon, cette classe de caractères correspondrait à uniquement le début de la chaîne d’entrée.)(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.)

La chaîne de remplacement (vbCrLf + "$&" en Visual Basic, "\n$&" en c#) ajoute une nouvelle ligne avant la chaîne correspondante.The replacement string (vbCrLf + "$&" in Visual Basic, "\n$&" in C#) adds a new line before the matched string. Notez que \n en C# exemple est interprété comme le caractère de saut de ligne par le compilateur c# ; il ne représente pas un échappement de caractères d’expression régulière.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.

Remarks

La recherche de correspondances démarre dans le input chaîne à la position spécifiée par le startat paramètre.The search for matches starts in the input string at the position specified by the startat parameter. L’expression régulière est le modèle défini par le constructeur pour actuel Regex objet.The regular expression is the pattern defined by the constructor for the current Regex object. Si count est négatif, les remplacements continuent jusqu'à la fin de la chaîne.If count is negative, replacements continue to the end of the string. Si count dépasse le nombre de correspondances, toutes les correspondances sont remplacées.If count exceeds the number of matches, all matches are replaced.

Le replacement paramètre spécifie la chaîne qui doit remplacer chaque correspondance dans input.The replacement parameter specifies the string that is to replace each match in input. replacement peut être constitué de n’importe quelle combinaison de texte littéral et substitutions.replacement can consist of any combination of literal text and substitutions. Par exemple, le modèle de remplacement a*${test}b insère la chaîne « un * » suivie de la sous-chaîne qui est mis en correspondance par le test groupe de capture, le cas échéant, suivie de la chaîne « b ».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". Le * caractère n’est pas reconnu comme un caractère de remplacement dans un modèle de remplacement.The * character is not recognized as a metacharacter within a replacement pattern.

Note

Les substitutions sont les éléments de langage d’expression régulière seulement sont reconnus dans un modèle de remplacement.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Tous les autres éléments de langage d’expression régulière, notamment caractère d’échappement, sont autorisées dans les modèles d’expressions régulières uniquement et ne sont pas reconnues dans les modèles de remplacement.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.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. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.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. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

See Also

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

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Les options spécifiées modifient l'opération correspondante. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance. The regular expression pattern to match.

replacement
String String String String

Chaîne de remplacement. The replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance. A bitwise combination of the enumeration values that provide options for matching.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si pattern n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite. A regular expression parsing error occurred.

input, pattern ou replacement a la valeur null. input, pattern, or replacement is null.

options n’est pas une combinaison valide au niveau du bit de valeurs RegexOptions. options is not a valid bitwise combination of RegexOptions values.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant utilise la Replace(String, String, String, RegexOptions) méthode pour remplacer les noms d’ordinateur et le lecteur locales dans un chemin d’accès UNC avec un chemin d’accès de fichier local.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. L’expression régulière utilise la Environment.MachineName propriété à inclure le nom de l’ordinateur local et le Environment.GetLogicalDrives méthode pour inclure les noms des lecteurs logiques.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. Toutes les comparaisons de chaîne d’expression régulière respectent la casse.All regular expression string comparisons are case-insensitive. Pour exécuter l’exemple, vous devez remplacer la chaîne littérale « Monordinateur » par le nom de votre ordinateur local.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

Le modèle d’expression régulière est défini par l’expression suivante :The regular expression pattern is defined by the following expression:

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

Le tableau suivant montre comment le modèle d'expression régulière est interprété.The following table shows how the regular expression pattern is interpreted.

MotifPattern Description Description
\\\\ Barre oblique inverse consécutif de correspondance deux (\) caractères.Match two consecutive backslash (\) characters. Étant donné que le caractère barre oblique inverse est interprété comme caractère d’échappement, chaque barre oblique inverse doit être précédé d’une autre barre oblique inverse.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Correspond à la chaîne retournée par la Environment.MachineName propriété.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Correspond à la période (.) caractères suivi d’un ou plusieurs caractères alphabétiques.Match the period (.) character followed by one or more word characters. Cette correspondance peut se produire zéro ou plusieurs fois.This match can occur zero or more times. La sous-expression mise en correspondance n’est pas capturée.The matched subexpression is not captured.
\\ Correspond à une barre oblique inverse (\) caractères.Match a backslash (\) character.
([" + driveNames + "]) Correspond à la classe de caractères qui se compose de lettres de lecteur individuelles.Match the character class that consists of the individual drive letters. Cette correspondance est la première sous-expression capturée.This match is the first captured subexpression.
\$ Correspond au signe dollar littéral ($) caractères.Match the literal dollar sign ($) character.

Le modèle de remplacement $1 remplace la correspondance entière par la première sous-expression capturée.The replacement pattern $1 replaces the entire match with the first captured subexpression. Autrement dit, il remplace le nom d’ordinateur et le lecteur UNC par la lettre de lecteur.That is, it replaces the UNC machine and drive name with the drive letter.

Remarks

La méthode statique Replace méthodes sont équivalentes à construire un Regex de l’objet avec le modèle d’expression régulière spécifiée et en appelant la méthode d’instance Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Si vous spécifiez RightToLeft pour le options de paramètre, la recherche de correspondances commence à la fin de la chaîne d’entrée et les déplace vers la gauche ; sinon, la recherche commence au début de la chaîne d’entrée et déplacé vers la droite.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.

Le replacement paramètre spécifie la chaîne qui doit remplacer chaque correspondance dans input.The replacement parameter specifies the string that is to replace each match in input. replacement peut être constitué de n’importe quelle combinaison de texte littéral et substitutions.replacement can consist of any combination of literal text and substitutions. Par exemple, le modèle de remplacement a*${test}b insère la chaîne « un * » suivie de la sous-chaîne qui est mis en correspondance par le test groupe de capture, le cas échéant, suivie de la chaîne « b ».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". Le * caractère n’est pas reconnu comme un caractère de remplacement dans un modèle de remplacement.The * character is not recognized as a metacharacter within a replacement pattern.

Note

Les substitutions sont les éléments de langage d’expression régulière seulement sont reconnus dans un modèle de remplacement.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Tous les autres éléments de langage d’expression régulière, notamment caractère d’échappement, sont autorisées dans les modèles d’expressions régulières uniquement et ne sont pas reconnues dans les modèles de remplacement.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée.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. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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.

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

Notes to Callers

Cette méthode expire après un intervalle est égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est appelée. 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. Si une valeur de délai d’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, ce qui empêche la méthode de délai d’expiration, est utilisé. 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. La méthode statique recommandée pour remplacer une correspondance de modèle est Replace(String, String, String, RegexOptions, TimeSpan), qui vous permet de définir l’intervalle de délai d’attente. The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

See Also

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

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance. The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement. A custom method that examines each match and returns either the original matched string or a replacement string.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf qu'une chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si pattern n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite. A regular expression parsing error occurred.

input, pattern ou evaluator est null. input, pattern, or evaluator is null.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant utilise une expression régulière pour extraire les mots individuels d’une chaîne, puis utilise un MatchEvaluator délégué à appeler une méthode nommée WordScramble qui brouille les lettres individuelles dans le mot.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. Pour ce faire, le WordScramble méthode crée un tableau qui contient les caractères dans la correspondance.To do this, the WordScramble method creates an array that contains the characters in the match. Il crée également un tableau parallèle qu’il remplit avec des nombres à virgule flottante aléatoire.It also creates a parallel array that it populates with random floating-point numbers. Les tableaux sont triés en appelant le Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) (méthode) et le tableau trié est fourni en tant qu’argument à un String constructeur de classe.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. Cette chaîne nouvellement créée est ensuite retournée par la WordScramble (méthode).This newly created string is then returned by the WordScramble method. Le modèle d’expression régulière \w+ correspond à un ou plusieurs caractères alphabétiques ; le moteur d’expression régulière continue à ajouter des caractères à la correspondance jusqu'à ce qu’il rencontre un caractère non alphabétique, par exemple un caractère d’espace blanc.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

Remarks

Le Regex.Replace(String, String, MatchEvaluator) méthode est utile pour remplacer une correspondance d’expression régulière si une des conditions suivantes est vraie :The Regex.Replace(String, String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Impossible de spécifier facilement la chaîne de remplacement par un modèle de remplacement d’expression régulière.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Résultats de la chaîne de remplacement d’un traitement effectué sur la chaîne correspondante.The replacement string results from some processing done on the matched string.

  • Résultats de la chaîne de remplacement d’un traitement conditionnel.The replacement string results from conditional processing.

La méthode revient à appeler le Regex.Matches(String, String) méthode et passer chaque Match objet retourné MatchCollection collection à la evaluator déléguer.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.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Le evaluator paramètre est le délégué d’une méthode personnalisée que vous définissez et qui examine chaque correspondance.The evaluator parameter is the delegate for a custom method that you define and that examines each match. La méthode personnalisée doit avoir la signature suivante pour faire correspondre le MatchEvaluator déléguer.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

Votre méthode personnalisée retourne une chaîne qui remplace l’entrée correspondante.Your custom method returns a string that replaces the matched input.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée.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. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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.

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

Notes to Callers

Cette méthode expire après un intervalle est égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est appelée. 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. Si une valeur de délai d’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, ce qui empêche la méthode de délai d’expiration, est utilisé. 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. La méthode statique recommandée pour l’évaluation et le remplacement d’une correspondance de modèle est Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), qui vous permet de définir l’intervalle de délai d’attente. 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.

See Also

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

Dans la chaîne d'entrée spécifiée, remplace toutes les chaînes qui correspondent à l'expression régulière spécifiée par une chaîne de remplacement spécifiée. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

pattern
String String String String

Modèle d’expression régulière à mettre en correspondance. The regular expression pattern to match.

replacement
String String String String

Chaîne de remplacement. The replacement string.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si pattern n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite. A regular expression parsing error occurred.

input, pattern ou replacement est null. input, pattern, or replacement is null.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant définit une expression régulière, \s+, qui correspond à un ou plusieurs caractères d’espace blanc.The following example defines a regular expression, \s+, that matches one or more white-space characters. La chaîne de remplacement, « », les remplace par un espace unique.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.

L’exemple suivant utilise la Replace(String, String, String) méthode pour remplacer les noms d’ordinateur et le lecteur locales dans un chemin d’accès UNC avec un chemin d’accès de fichier local.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. L’expression régulière utilise la Environment.MachineName propriété à inclure le nom de l’ordinateur local et le Environment.GetLogicalDrives méthode pour inclure les noms des lecteurs logiques.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. Pour exécuter l’exemple, vous devez remplacer la chaîne littérale « Monordinateur » par le nom de votre ordinateur local.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

Le modèle d’expression régulière est défini par l’expression suivante :The regular expression pattern is defined by the following expression:

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

Le tableau suivant montre comment le modèle d'expression régulière est interprété.The following table shows how the regular expression pattern is interpreted.

MotifPattern Description Description
\\\\ Barre oblique inverse consécutif de correspondance deux (\) caractères.Match two consecutive backslash (\) characters. Étant donné que le caractère barre oblique inverse est interprété comme caractère d’échappement, chaque barre oblique inverse doit être précédé d’une autre barre oblique inverse.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
(?i:" + Environment.MachineName + ") Procédez à la casse de la chaîne retournée par la Environment.MachineName propriété.Perform a case-insensitive match of the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Correspond à la période (.) caractères suivi d’un ou plusieurs caractères alphabétiques.Match the period (.) character followed by one or more word characters. Cette correspondance peut se produire zéro ou plusieurs fois.This match can occur zero or more times. La sous-expression mise en correspondance n’est pas capturée.The matched subexpression is not captured.
\\ Correspond à une barre oblique inverse (\) caractères.Match a backslash (\) character.
((?i:[" + driveNames + "])) Procédez à la casse de la classe de caractères est constitué par les lettres de lecteur individuelles.Perform a case-insensitive match of the character class that consists of the individual drive lettters. Cette correspondance est la première sous-expression capturée.This match is the first captured subexpression.
\$ Correspond au signe dollar littéral ($) caractères.Match the literal dollar sign ($) character.

Le modèle de remplacement $1 remplace la correspondance entière par la première sous-expression capturée.The replacement pattern $1 replaces the entire match with the first captured subexpression. Autrement dit, il remplace le nom d’ordinateur et le lecteur UNC par la lettre de lecteur.That is, it replaces the UNC machine and drive name with the drive letter.

Remarks

La méthode statique Replace méthodes sont équivalentes à construire un Regex de l’objet avec le modèle d’expression régulière spécifiée et en appelant la méthode d’instance Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

Le pattern paramètre se compose des éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET Framework et langage des expressions régulières - aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. La recherche de correspondances commence au début de la input chaîne.The search for matches starts at the beginning of the input string.

Le replacement paramètre spécifie la chaîne qui doit remplacer chaque correspondance dans input.The replacement parameter specifies the string that is to replace each match in input. replacement peut être constitué de n’importe quelle combinaison de texte littéral et substitutions.replacement can consist of any combination of literal text and substitutions. Par exemple, le modèle de remplacement a*${test}b insère la chaîne « un * » suivie de la sous-chaîne qui est mis en correspondance par le test groupe de capture, le cas échéant, suivie de la chaîne « b ».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". Le * caractère n’est pas reconnu comme un caractère de remplacement dans un modèle de remplacement.The * character is not recognized as a metacharacter within a replacement pattern.

Note

Les substitutions sont les éléments de langage d’expression régulière seulement sont reconnus dans un modèle de remplacement.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Tous les autres éléments de langage d’expression régulière, notamment caractère d’échappement, sont autorisées dans les modèles d’expressions régulières uniquement et ne sont pas reconnues dans les modèles de remplacement.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée.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. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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.

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

Notes to Callers

Cette méthode expire après un intervalle est égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est appelée. 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. Si une valeur de délai d’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, ce qui empêche la méthode de délai d’expiration, est utilisé. 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. La méthode statique recommandée pour remplacer une correspondance de modèle est Replace(String, String, String, RegexOptions, TimeSpan), qui vous permet de définir l’intervalle de délai d’attente. The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

See Also

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

Dans une chaîne d’entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

replacement
String String String String

Chaîne de remplacement. The replacement string.

count
Int32 Int32 Int32 Int32

Nombre maximal d’occurrences du remplacement. The maximum number of times the replacement can occur.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si le modèle d’expression régulière n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

input ou replacement a la valeur null. input or replacement is null.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant remplace les cinq premières occurrences de caractères en double avec un caractère unique.The following example replaces the first five occurrences of duplicated characters with a single character. Le modèle d’expression régulière (\w)\1 correspond à des occurrences consécutives d’un caractère unique et affecte la première occurrence au premier groupe de capture.The regular expression pattern (\w)\1 matches consecutive occurrences of a single character and assigns the first occurrence to the first capturing group. Le modèle de remplacement $1 remplace la correspondance entière par le premier groupe capturé.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'

Remarks

La recherche de correspondances commence au début de la input chaîne.The search for matches starts at the beginning of the input string. L’expression régulière est le modèle qui est défini par le constructeur pour actuel Regex objet.The regular expression is the pattern that is defined by the constructor for the current Regex object. Si count est négatif, les remplacements continuent jusqu'à la fin de la chaîne.If count is negative, replacements continue to the end of the string. Si count dépasse le nombre de correspondances, toutes les correspondances sont remplacées.If count exceeds the number of matches, all matches are replaced.

Le replacement paramètre spécifie la chaîne qui doit remplacer la première count correspond à dans input.The replacement parameter specifies the string that is to replace the first count matches in input. replacement peut être constitué de n’importe quelle combinaison de texte littéral et substitutions.replacement can consist of any combination of literal text and substitutions. Par exemple, le modèle de remplacement a*${test}b insère la chaîne « un * » suivie de la sous-chaîne qui est mis en correspondance par le test groupe de capture, le cas échéant, suivie de la chaîne « b ».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". Le * caractère n’est pas reconnu comme un caractère de remplacement dans un modèle de remplacement.The * character is not recognized as a metacharacter within a replacement pattern.

Note

Les substitutions sont les éléments de langage d’expression régulière seulement sont reconnus dans un modèle de remplacement.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Tous les autres éléments de langage d’expression régulière, notamment caractère d’échappement, sont autorisées dans les modèles d’expressions régulières uniquement et ne sont pas reconnues dans les modèles de remplacement.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.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. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.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. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

See Also

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

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à une expression régulière spécifiée par une chaîne retournée par un délégué MatchEvaluator. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement. A custom method that examines each match and returns either the original matched string or a replacement string.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf qu'une chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si le modèle d’expression régulière n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

input ou evaluator a la valeur null. input or evaluator is null.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple de code suivant affiche une chaîne d’origine, met en correspondance chaque mot dans la chaîne d’origine, convertit le premier caractère de chaque correspondance en majuscules, puis affiche la chaîne convertie.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]

Remarks

Le Regex.Replace(String, MatchEvaluator) méthode est utile pour remplacer une correspondance d’expression régulière si une des conditions suivantes est vraie :The Regex.Replace(String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Impossible de spécifier facilement la chaîne de remplacement par un modèle de remplacement d’expression régulière.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Résultats de la chaîne de remplacement d’un traitement effectué sur la chaîne correspondante.The replacement string results from some processing done on the matched string.

  • Résultats de la chaîne de remplacement d’un traitement conditionnel.The replacement string results from conditional processing.

La méthode revient à appeler le Regex.Matches(String) méthode et passer chaque Match objet retourné MatchCollection collection à la evaluator déléguer.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.

L’expression régulière est le modèle défini par le constructeur pour actuel Regex objet.The regular expression is the pattern defined by the constructor for the current Regex object.

Le evaluator paramètre est le délégué d’une méthode personnalisée que vous définissez et qui examine chaque correspondance.The evaluator parameter is the delegate for a custom method that you define and that examines each match. La méthode personnalisée doit avoir la signature suivante pour faire correspondre le MatchEvaluator déléguer.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

Votre méthode personnalisée retourne une chaîne qui remplace l’entrée correspondante.Your custom method returns a string that replaces the matched input.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.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. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.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. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

See Also

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

Dans une chaîne d’entrée spécifiée, remplace toutes les chaînes qui correspondent à un modèle d’expression régulière par une chaîne de remplacement spécifiée. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

replacement
String String String String

Chaîne de remplacement. The replacement string.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si le modèle d’expression régulière n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

input ou replacement a la valeur null. input or replacement is null.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant définit une expression régulière, \s+, qui correspond à un ou plusieurs caractères d’espace blanc.The following example defines a regular expression, \s+, that matches one or more white-space characters. La chaîne de remplacement, « », les remplace par un espace unique.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.

L’exemple suivant définit une expression régulière, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?et un modèle de remplacement, $2, qui supprime un préfixe ou un symbole de devise à droite d’une valeur numérique.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'

L'expression régulière est interprétée comme indiqué dans le tableau suivant.The regular expression is interpreted as shown in the following table.

MotifPattern Description Description
\p{Sc} Mettre en correspondance un symbole monétaire.Match a currency symbol. {Sc} désigne n’importe quel caractère qui est membre du symbole Unicode, catégorie de devise.{Sc} denotes any character that is a member of the Unicode Symbol, Currency category.
\s? Mettre en correspondance zéro ou un espace blanc.Match zero or one white-space character.
(\p{Sc}\s?)? Correspond à zéro ou une occurrence de la combinaison d’un symbole monétaire suivi par zéro ou un caractère d’espace blanc.Match zero or one occurrence of the combination of a currency symbol followed by zero or one white-space character. Il s'agit du premier groupe de capture.This is the first capturing group.
\d+ Mettre en correspondance un ou plusieurs chiffres décimaux.Match one or more decimal digits.
\.? Correspond à zéro ou une occurrence d’une période (utilisée comme un caractère de séparateur décimal).Match zero or one occurrence of a period (used as a decimal separator character).
((?<=\.)\d+)? Si une période est le caractère précédent, correspond à un ou plusieurs chiffres décimaux.If a period is the previous character, match one or more decimal digits. Ce modèle peut être mis en correspondance zéro ou une fois.This pattern can be matched either zero or one time.
(\d+\.?((?<=\.)\d+)?) Mettre en correspondance d’un ou plusieurs chiffres décimaux, suivi d’un point facultatif et de chiffres décimaux supplémentaires.Match the pattern of one or more decimal digits followed by an optional period and additional decimal digits. Il s'agit du deuxième groupe de capture.This is the second capturing group. L’appel à la Replace(String, String) méthode remplace la correspondance entière par la valeur de ce groupe capturé.The call to the Replace(String, String) method replaces the entire match with the value of this captured group.
(?(1)|\s?\p{Sc})? Si le premier groupe capturé existe, correspond à une chaîne vide.If the first captured group exists, match an empty string. Sinon, mettre en correspondance zéro ou un espace blanc suivi par un symbole monétaire.Otherwise, match zero or one white-space character followed by a currency symbol.

Remarks

La recherche de correspondances commence au début de la input chaîne.The search for matches starts at the beginning of the input string. L’expression régulière est le modèle défini par le constructeur pour actuel Regex objet.The regular expression is the pattern defined by the constructor for the current Regex object.

Le replacement paramètre spécifie la chaîne qui doit remplacer chaque correspondance dans input.The replacement parameter specifies the string that is to replace each match in input. replacement peut être constitué de n’importe quelle combinaison de texte littéral et substitutions.replacement can consist of any combination of literal text and substitutions. Par exemple, le modèle de remplacement a*${test}b insère la chaîne « un * » suivie de la sous-chaîne qui est mis en correspondance par le test groupe de capture, le cas échéant, suivie de la chaîne « b ».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". Le * caractère n’est pas reconnu comme un caractère de remplacement dans un modèle de remplacement.The * character is not recognized as a metacharacter within a replacement pattern.

Note

Les substitutions sont les éléments de langage d’expression régulière seulement sont reconnus dans un modèle de remplacement.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Tous les autres éléments de langage d’expression régulière, notamment caractère d’échappement, sont autorisées dans les modèles d’expressions régulières uniquement et ne sont pas reconnues dans les modèles de remplacement.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.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. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.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. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

See Also

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

Dans la chaîne d'entrée spécifiée, remplace le nombre maximal spécifié de chaînes qui correspondent à un modèle d'expression régulière par une chaîne retournée par un délégué MatchEvaluator. 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

Paramètres

input
String String String String

Chaîne dans laquelle une correspondance doit être recherchée. The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement. A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32 Int32 Int32 Int32

Nombre maximal de fois où le remplacement aura lieu. The maximum number of times the replacement will occur.

Returns

Nouvelle chaîne identique à la chaîne d'entrée, sauf qu'une chaîne de remplacement remplace chaque chaîne correspondante. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si le modèle d’expression régulière n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

input ou evaluator a la valeur null. input or evaluator is null.

Un délai d’attente a expiré. A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes. For more information about time-outs, see the Remarks section.

Examples

L’exemple suivant utilise une expression régulière pour délibérément mal orthographier la moitié des mots contenus dans une liste.The following example uses a regular expression to deliberately misspell half of the words in a list. Elle utilise l’expression régulière \w*(ie|ei)\w* pour faire correspondre les mots qui incluent les caractères « ie » ou « AE ».It uses the regular expression \w*(ie|ei)\w* to match words that include the characters "ie" or "ei". Il passe la première moitié de mots correspondants à la ReverseLetter (méthode), qui, à son tour, utilise le Replace(String, String, String, RegexOptions) méthode à inverser « i » et « e » dans la chaîne correspondante.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. Les mots restants restent inchangés.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

L'expression régulière \w*(ie|ei)\w* est définie comme indiqué dans le tableau suivant.The regular expression \w*(ie|ei)\w* is defined as shown in the following table.

MotifPattern Description Description
\w* Mettre en correspondance zéro, un ou plusieurs caractères alphabétiques.Match zero or more word characters.
(ie|ei) Mettre en correspondance « ie » ou « AE ».Match either "ie" or "ei".
\w* Mettre en correspondance zéro, un ou plusieurs caractères alphabétiques.Match zero or more word characters.

Le modèle d’expression régulière ([ie])([ie]) dans le ReverseLetter méthode correspond à la première « i » ou « e » dans la diphtongue « ie » ou « AE » et lui attribue la lettre au premier groupe de capture.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. Il correspond à la deuxième « i » ou « e » et lui attribue la lettre au deuxième groupe de capture.It matches the second "i" or "e" and assigns the letter to the second capturing group. Les deux caractères sont alors annulées en appelant le Replace(String, String, String) méthode avec le modèle de remplacement $2$1.The two characters are then reversed by calling the Replace(String, String, String) method with the replacement pattern $2$1.

Remarks

Le Regex.Replace(String, MatchEvaluator, Int32) méthode est utile pour remplacer une correspondance d’expression régulière si une des conditions suivantes est vraie :The Regex.Replace(String, MatchEvaluator, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Impossible de spécifier facilement la chaîne de remplacement par un modèle de remplacement d’expression régulière.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Résultats de la chaîne de remplacement d’un traitement effectué sur la chaîne correspondante.The replacement string results from some processing done on the matched string.

  • Résultats de la chaîne de remplacement d’un traitement conditionnel.The replacement string results from conditional processing.

La méthode revient à appeler le Regex.Matches(String) (méthode) et en passant la première count Match objets retourné MatchCollection collection à la evaluator déléguer.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.

L’expression régulière est le modèle défini par le constructeur pour actuel Regex objet.The regular expression is the pattern defined by the constructor for the current Regex object.

Le evaluator paramètre est le délégué d’une méthode personnalisée que vous définissez et qui examine chaque correspondance.The evaluator parameter is the delegate for a custom method that you define and that examines each match. La méthode personnalisée doit avoir la signature suivante pour faire correspondre le MatchEvaluator déléguer.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

Votre méthode personnalisée retourne une chaîne qui remplace l’entrée correspondante.Your custom method returns a string that replaces the matched input.

Le RegexMatchTimeoutException exception est levée si la durée d’exécution de l’opération de remplacement dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur.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. Si vous ne définissez pas un intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse une valeur de délai d’attente établie pour le domaine d’application dans lequel le Regex objet est créé.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. Si aucun délai d’attente n’est défini dans le Regex appel de constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.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

Étant donné que la méthode retourne input inchangé s’il n’existe aucune correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a apporté des remplacements pour la chaîne d’entrée.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.

See Also

Applies to