Regex.Replace Méthode

Référence

Définition

Espace de noms:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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.

Surcharges

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.
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.
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. 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.
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. Les options spécifiées modifient l'opération correspondante.
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. 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.
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. Les options spécifiées modifient l'opération correspondante.
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.
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.
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.
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.
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.
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.

Replace(String, MatchEvaluator, Int32, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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.

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

Chaîne dans laquelle une correspondance doit être recherchée.

evaluator: MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement.

count: Int32

Nombre maximal de fois où le remplacement aura lieu.

startat: Int32

Position du caractère dans la chaîne d’entrée où la recherche commence.

Retours

String

Nouvelle chaîne identique à la chaîne d'entrée, sauf qu'une chaîne de remplacement remplace chaque chaîne correspondante. 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.

Exceptions

ArgumentNullException

input ou evaluator est null.

ArgumentOutOfRangeException

startat est inférieur à zéro ou supérieur à la longueur de input.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Remarques

La Regex.Replace(String, MatchEvaluator, Int32, Int32) méthode est utile pour remplacer une correspondance d’expression régulière si l’une des conditions suivantes est remplie :

La chaîne de remplacement ne peut pas être spécifiée facilement par un modèle de remplacement d’expression régulière.
La chaîne de remplacement résulte d’un traitement effectué sur la chaîne correspondante.
La chaîne de remplacement résulte du traitement conditionnel.

La méthode équivaut à appeler la Regex.Matches(String, Int32) méthode et à transmettre les premiers countMatch objets de la collection retournée MatchCollection au evaluator délégué.

Pour plus d’informations sur startat, consultez la section Remarques de Match(String, Int32).

L’expression régulière est le modèle défini par le constructeur pour l’objet actuel Regex .

Le evaluator paramètre est le délégué d’une méthode personnalisée que vous définissez et qui examine chaque correspondance. La méthode personnalisée doit avoir la signature suivante pour correspondre au MatchEvaluator délégué.

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.

L’exception RegexMatchTimeoutException 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. Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du Regex constructeur ou dans les propriétés du domaine d’application, ou si la valeur du délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée

Étant donné que la méthode retourne input inchangée en l’absence de correspondance, vous pouvez utiliser la Object.ReferenceEquals méthode pour déterminer si la méthode a effectué des remplacements à la chaîne d’entrée.

Voir aussi

S’applique à

Replace(String, String, String)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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.

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

Chaîne dans laquelle une correspondance doit être recherchée.

pattern: String

Modèle d’expression régulière à mettre en correspondance.

replacement: String

Chaîne de remplacement.

Retours

String

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. Si pattern n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée.

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input, pattern ou replacement est null.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant définit une expression régulière, \s+, qui correspond à un ou plusieurs espaces blancs. La chaîne de remplacement, « », les remplace par un seul espace.

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

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 :

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

Le tableau suivant montre comment le modèle d'expression régulière est interprété.

Modèle	Description
`\\\\`	Mettre en correspondance deux barres obliques inverses consécutives (`\`). Étant donné que la barre oblique inverse est interprétée comme le caractère d’échappement, chaque barre oblique inverse doit être placée dans une séquence d’échappement avec une autre barre oblique inverse.
`(?i:" + Environment.MachineName + ")`	Effectuez une correspondance qui ne respecte pas la casse de la chaîne retournée par la Environment.MachineName propriété .
`(?:\.\w+)*`	Mettre en correspondance le caractère de point (`.`) suivi d’un ou de plusieurs caractères de mot. Cette correspondance peut se produire zéro ou plusieurs fois. La sous-expression correspondante n’est pas capturée.
`\\`	Mettre en correspondance une barre oblique inverse (`\`).
`((?i:[" + driveNames + "]))`	Effectuez une correspondance qui ne respecte pas la casse de la classe de caractères qui se compose des lettres de lecteur individuelles. Cette correspondance est la première sous-expression capturée.
`\$`	Mettre en correspondance le signe dollar littéral (`$`).

Le modèle de $1 remplacement remplace la correspondance entière par la première sous-expression capturée. Autrement dit, il remplace la machine UNC et le nom du lecteur par la lettre de lecteur.

Remarques

Les méthodes statiques Replace revient à construire un Regex objet avec le modèle d’expression régulière spécifié et à appeler la méthode Replaceinstance .

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET et Langage d’expression régulière - Référence rapide. La recherche de correspondances commence au début de la input chaîne.

Le replacement paramètre spécifie la chaîne qui doit remplacer chaque correspondance dans input. replacement peut être constitué de n’importe quelle combinaison de texte littéral et de substitutions. Par exemple, le modèle a*${test}b de remplacement insère la chaîne « a* » suivie de la sous-chaîne qui correspond au groupe de capture, le test cas échéant, suivie de la chaîne « b ». Le caractère * n’est pas reconnu comme métacharacteur dans un modèle de remplacement.

Notes

Les substitutions sont les seuls éléments de langage d’expression régulière qui sont reconnus dans un modèle de remplacement. Tous les autres éléments de langage d’expression régulière, y compris les échappements de caractères, sont autorisés uniquement dans les modèles d’expression régulière et ne sont pas reconnus dans les modèles de remplacement.

L’exception RegexMatchTimeoutException est levée si le temps 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. 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.

Notes pour les appelants

Cette méthode expire après un intervalle égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est appelée. Si aucune valeur de délai d’attente n’a été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode d’expirer, est utilisée. 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.

Voir aussi

S’applique à

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

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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

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

Chaîne dans laquelle une correspondance doit être recherchée.

pattern: String

Modèle d’expression régulière à mettre en correspondance.

evaluator: MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement.

options: RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.

matchTimeout: TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.

Retours

String

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input, pattern ou evaluator est null.

ArgumentOutOfRangeException

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.

- ou -

matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

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é pour appeler une méthode nommée WordScramble qui brousse les lettres individuelles dans le mot. Pour ce faire, la WordScramble méthode crée un tableau qui contient les caractères de la correspondance. Il crée également un tableau parallèle qu’il remplit avec des nombres à virgule flottante aléatoires. Les tableaux sont triés en appelant la 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. Cette chaîne nouvellement créée est ensuite retournée par la WordScramble méthode . Le modèle \w+ d’expression régulière correspond à un ou plusieurs caractères de mot ; le moteur d’expression régulière continue d’ajouter des caractères à la correspondance jusqu’à ce qu’il rencontre un caractère non-mot, tel qu’un caractère d’espace blanc. L’appel à la Replace(String, String, MatchEvaluator, RegexOptions) méthode inclut l’option RegexOptions.IgnorePatternWhitespace afin que le commentaire dans le modèle \w+ # Matches all the characters in a word. d’expression régulière soit ignoré par le moteur d’expression régulière.

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

Remarques

La Regex.Replace(String, String, MatchEvaluator, RegexOptions) méthode est utile pour remplacer une correspondance d’expression régulière si l’une des conditions suivantes est vraie :

Si la chaîne de remplacement ne peut pas être spécifiée facilement par un modèle de remplacement d’expression régulière.
Si la chaîne de remplacement résulte d’un traitement effectué sur la chaîne correspondante.
Si la chaîne de remplacement résulte d’un traitement conditionnel.

La méthode équivaut à appeler la Regex.Matches(String, String, RegexOptions) méthode et à passer chaque Match objet de la collection retournée MatchCollection au evaluator délégué.

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.

Si vous spécifiez RightToLeft pour le options paramètre, la recherche de correspondances commence à la fin de la chaîne d’entrée et se déplace vers la gauche ; sinon, la recherche commence au début de la chaîne d’entrée et se déplace vers la droite.

Le matchTimeout paramètre spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant d’expirer. La définition d’un intervalle de délai d’attente empêche les expressions régulières qui s’appuient sur un retour en arrière excessif de sembler « cesser de répondre lorsqu’elles traitent une entrée qui contient des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et le retour en arrière. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une RegexMatchTimeoutException exception. matchTimeout remplace toute valeur de délai d’attente par défaut définie pour le domaine d’application dans lequel la méthode s’exécute.

Notes pour les appelants

Nous vous recommandons de définir le matchTimeout paramètre sur une valeur appropriée, par exemple deux secondes. Si vous désactivez les délais d’expiration en spécifiant InfiniteMatchTimeout, le moteur d’expression régulière offre des performances légèrement meilleures. Toutefois, vous devez désactiver les délais d’expiration uniquement dans les conditions suivantes :

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. Cela exclut le texte entré dynamiquement par les utilisateurs.
Lorsque le modèle d’expression régulière a été soigneusement testé pour s’assurer qu’il gère efficacement les correspondances, les non-correspondances et les correspondances proches.
Lorsque le modèle d’expression régulière ne contient aucun élément de langage connu pour provoquer un retour excessif en arrière lors du traitement d’une correspondance proche.

Voir aussi

S’applique à

Replace(String, String, MatchEvaluator, RegexOptions)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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. Les options spécifiées modifient l'opération correspondante.

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

Chaîne dans laquelle une correspondance doit être recherchée.

pattern: String

Modèle d’expression régulière à mettre en correspondance.

evaluator: MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement.

options: RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.

Retours

String

Nouvelle chaîne identique à la chaîne d'entrée, sauf qu'une chaîne de remplacement remplace chaque chaîne correspondante. Si pattern n’a pas de correspondance dans l’instance actuelle, la méthode retourne l’instance actuelle inchangée.

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input, pattern ou evaluator est null.

ArgumentOutOfRangeException

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

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

Remarques

La Regex.Replace(String, String, MatchEvaluator, RegexOptions) méthode est utile pour remplacer une correspondance d’expression régulière dans si l’une des conditions suivantes est vraie :

La chaîne de remplacement ne peut pas être spécifiée facilement par un modèle de remplacement d’expression régulière.
La chaîne de remplacement résulte d’un traitement effectué sur la chaîne correspondante.
La chaîne de remplacement résulte d’un traitement conditionnel.

La méthode équivaut à appeler la Regex.Matches(String, String, RegexOptions) méthode et à passer chaque Match objet de la collection retournée MatchCollection au evaluator délégué.

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.

Voir aussi

S’applique à

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

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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

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

Chaîne dans laquelle une correspondance doit être recherchée.

pattern: String

Modèle d’expression régulière à mettre en correspondance.

replacement: String

Chaîne de remplacement.

options: RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.

matchTimeout: TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.

Retours

String

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input, pattern ou replacement est null.

ArgumentOutOfRangeException

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.

- ou -

matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant utilise la Replace(String, String, String, RegexOptions, TimeSpan) méthode pour remplacer les noms de l’ordinateur local et des lecteurs dans un chemin UNC par un chemin d’accès de fichier local. L’expression régulière utilise la Environment.MachineName propriété pour inclure le nom de l’ordinateur local et la Environment.GetLogicalDrives méthode pour inclure les noms des lecteurs logiques. Toutes les comparaisons de chaînes d’expression régulière ne respectent pas la casse, et toute opération de remplacement unique expire si une correspondance est introuvable en 0,5 seconde. Pour exécuter correctement l’exemple, vous devez remplacer la chaîne littérale « MyMachine » par le nom de votre ordinateur local.

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 :

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

Le tableau suivant montre comment le modèle d'expression régulière est interprété.

Modèle	Description
`\\\\`	Mettre en correspondance deux caractères de barre oblique inverse (`\`) consécutifs. Étant donné que le caractère barre oblique inverse est interprété comme le caractère d’échappement, chaque barre oblique inverse doit être placée dans un échappement avec une autre barre oblique inverse.
`+ Environment.MachineName +`	Correspond à la chaîne retournée par la Environment.MachineName propriété .
`(?:\.\w+)*`	Faire correspondre le caractère de point (`.`) suivi d’un ou plusieurs caractères de mot. Cette correspondance peut se produire zéro ou plusieurs fois. La sous-expression correspondante n’est pas capturée.
`\\`	Faire correspondre un caractère de barre oblique inverse (`\`).
`([" + driveNames + "])`	Correspond à la classe de caractères qui se compose des lettres de lecteur individuelles. Cette correspondance est la première sous-expression capturée.
`\$`	Correspond au caractère de signe dollar littéral (`$`).

Le modèle $1 de remplacement remplace la correspondance entière par la première sous-expression capturée. Autrement dit, il remplace la machine UNC et le nom du lecteur par la lettre de lecteur.

Remarques

Les méthodes statiques Replace sont équivalentes à la construction d’un Regex objet avec le modèle d’expression régulière spécifié et à l’appel de la méthode Replaceinstance .

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à correspondre. Pour plus d’informations sur les expressions régulières, consultez Expressions régulières .NET et Langage d’expression régulière - Référence rapide. Si vous spécifiez RightToLeft pour le options paramètre, la recherche de correspondances commence à la fin de la chaîne d’entrée et se déplace vers la gauche ; sinon, la recherche commence au début de la chaîne d’entrée et se déplace vers la droite.

Le replacement paramètre spécifie la chaîne qui doit remplacer chaque correspondance dans input. replacement peut se composer de n’importe quelle combinaison de texte littéral et de substitutions. Par exemple, le modèle a*${test}b de remplacement insère la chaîne « a* » suivie de la sous-chaîne qui correspond au groupe de capture, le test cas échéant, suivie de la chaîne « b ». Le caractère * n’est pas reconnu comme métacharacteur dans un modèle de remplacement.

Notes

Le matchTimeout paramètre spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant d’expirer. La définition d’un intervalle de délai d’attente empêche les expressions régulières qui s’appuient sur un retour excessif de ne plus répondre lorsqu’elles traitent une entrée qui contient des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et le retour en arrière. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une RegexMatchTimeoutException exception. matchTimeout remplace toute valeur de délai d’attente par défaut définie pour le domaine d’application dans lequel la méthode s’exécute.

Notes pour les appelants

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. Cela exclut le texte entré dynamiquement par les utilisateurs.
Lorsque le modèle d’expression régulière a été soigneusement testé pour s’assurer qu’il gère efficacement les correspondances, les non-correspondances et les correspondances proches.
Lorsque le modèle d’expression régulière ne contient aucun élément de langage connu pour provoquer un retour excessif en arrière lors du traitement d’une correspondance proche.

Voir aussi

S’applique à

Replace(String, String, String, RegexOptions)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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. Les options spécifiées modifient l'opération correspondante.

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

Chaîne dans laquelle une correspondance doit être recherchée.

pattern: String

Modèle d’expression régulière à mettre en correspondance.

replacement: String

Chaîne de remplacement.

options: RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.

Retours

String

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input, pattern ou replacement est null.

ArgumentOutOfRangeException

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant utilise la Replace(String, String, String, RegexOptions) méthode pour remplacer les noms de l’ordinateur local et des lecteurs dans un chemin UNC par un chemin d’accès de fichier local. L’expression régulière utilise la Environment.MachineName propriété pour inclure le nom de l’ordinateur local et la Environment.GetLogicalDrives méthode pour inclure les noms des lecteurs logiques. Toutes les comparaisons de chaînes d’expression régulière ne respectent pas la casse. Pour exécuter correctement l’exemple, vous devez remplacer la chaîne littérale « MyMachine » par le nom de votre ordinateur local.

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 :

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

Le tableau suivant montre comment le modèle d'expression régulière est interprété.

Modèle	Description
`\\\\`	Mettre en correspondance deux caractères de barre oblique inverse (`\`) consécutifs. Étant donné que le caractère barre oblique inverse est interprété comme le caractère d’échappement, chaque barre oblique inverse doit être placée dans un échappement avec une autre barre oblique inverse.
`+ Environment.MachineName +`	Correspond à la chaîne retournée par la Environment.MachineName propriété .
`(?:\.\w+)*`	Faire correspondre le caractère de point (`.`) suivi d’un ou plusieurs caractères de mot. Cette correspondance peut se produire zéro ou plusieurs fois. La sous-expression correspondante n’est pas capturée.
`\\`	Faire correspondre un caractère de barre oblique inverse (`\`).
`([" + driveNames + "])`	Correspond à la classe de caractères qui se compose des lettres de lecteur individuelles. Cette correspondance est la première sous-expression capturée.
`\$`	Correspond au caractère de signe dollar littéral (`$`).

Remarques

Les méthodes statiques Replace sont équivalentes à la construction d’un Regex objet avec le modèle d’expression régulière spécifié et à l’appel de la méthode Replaceinstance .

Notes

Notes pour les appelants

Cette méthode expire après un intervalle égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est appelée. Si aucune valeur de délai d’attente n’a été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode d’expirer, est utilisée. La méthode statique recommandée pour remplacer une correspondance de modèle est Replace(String, String, String, RegexOptions, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

S’applique à

Replace(String, MatchEvaluator)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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.

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

Chaîne dans laquelle une correspondance doit être recherchée.

evaluator: MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement.

Retours

String

Exceptions

ArgumentNullException

input ou evaluator est null.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple de code suivant affiche une chaîne d’origine, correspond à chaque mot de la chaîne d’origine, convertit le premier caractère de chaque correspondance en majuscules, puis affiche la chaîne convertie.

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]

Remarques

La Regex.Replace(String, MatchEvaluator) méthode est utile pour remplacer une correspondance d’expression régulière si l’une des conditions suivantes est vraie :

La chaîne de remplacement ne peut pas être spécifiée facilement par un modèle de remplacement d’expression régulière.
La chaîne de remplacement résulte d’un traitement effectué sur la chaîne correspondante.
La chaîne de remplacement résulte d’un traitement conditionnel.

La méthode équivaut à appeler la Regex.Matches(String) méthode et à passer chaque Match objet de la collection retournée MatchCollection au evaluator délégué.

L’expression régulière est le modèle défini par le constructeur pour l’objet actif Regex .

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.

L’exception RegexMatchTimeoutException est levée si le temps 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. Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du Regex 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

Voir aussi

S’applique à

Replace(String, MatchEvaluator, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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.

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

Chaîne dans laquelle une correspondance doit être recherchée.

evaluator: MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement.

count: Int32

Nombre maximal de fois où le remplacement aura lieu.

Retours

String

Exceptions

ArgumentNullException

input ou evaluator est null.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant utilise une expression régulière pour mal orthographié délibérément la moitié des mots d’une liste. Il utilise l’expression \w*(ie|ei)\w* régulière pour faire correspondre les mots qui incluent les caractères « ie » ou « ei ». Il transmet la première moitié des mots correspondants à la ReverseLetter méthode, qui, à son tour, utilise la Replace(String, String, String, RegexOptions) méthode pour inverser « i » et « e » dans la chaîne correspondante. Les mots restants restent inchangés.

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.

Modèle	Description
`\w*`	Mettre en correspondance zéro, un ou plusieurs caractères alphabétiques.
`(ie\|ei)`	Correspond à « ie » ou « ei ».
`\w*`	Mettre en correspondance zéro, un ou plusieurs caractères alphabétiques.

Le modèle ([ie])([ie]) d’expression régulière dans la ReverseLetter méthode correspond au premier « i » ou « e » de la diphtongue « ie » ou « ei » et affecte la lettre au premier groupe de capture. Il correspond au deuxième « i » ou « e » et affecte la lettre au deuxième groupe de capture. Les deux caractères sont ensuite inversés en appelant la Replace(String, String, String) méthode avec le modèle $2$1de remplacement .

Remarques

La Regex.Replace(String, MatchEvaluator, Int32) méthode est utile pour remplacer une correspondance d’expression régulière si l’une des conditions suivantes est vraie :

La chaîne de remplacement ne peut pas être spécifiée facilement par un modèle de remplacement d’expression régulière.
La chaîne de remplacement résulte d’un traitement effectué sur la chaîne correspondante.
La chaîne de remplacement résulte d’un traitement conditionnel.

La méthode équivaut à appeler la Regex.Matches(String) méthode et à passer les premiers countMatch objets de la collection retournée MatchCollection au evaluator délégué.

L’expression régulière est le modèle défini par le constructeur pour l’objet actif Regex .

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.

Voir aussi

S’applique à

Replace(String, String, MatchEvaluator)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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.

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

Chaîne dans laquelle une correspondance doit être recherchée.

pattern: String

Modèle d’expression régulière à mettre en correspondance.

evaluator: MatchEvaluator

Méthode personnalisée qui examine chaque correspondance et retourne la chaîne correspondante d'origine ou une chaîne de remplacement.

Retours

String

Exceptions

ArgumentException

Une erreur d’analyse d’expression régulière s’est produite.

ArgumentNullException

input, pattern ou evaluator est null.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

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

Remarques

La Regex.Replace(String, String, MatchEvaluator) méthode est utile pour remplacer une correspondance d’expression régulière si l’une des conditions suivantes est vraie :

La chaîne de remplacement ne peut pas être spécifiée facilement par un modèle de remplacement d’expression régulière.
La chaîne de remplacement résulte d’un traitement effectué sur la chaîne correspondante.
La chaîne de remplacement résulte d’un traitement conditionnel.

La méthode équivaut à appeler la Regex.Matches(String, String) méthode et à passer chaque Match objet de la collection retournée MatchCollection au evaluator délégué.

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.

Notes pour les appelants

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

Voir aussi

S’applique à

Replace(String, String, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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.

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

Chaîne dans laquelle une correspondance doit être recherchée.

replacement: String

Chaîne de remplacement.

count: Int32

Nombre maximal d’occurrences du remplacement.

Retours

String

Nouvelle chaîne identique à la chaîne d'entrée, sauf que la chaîne de remplacement remplace chaque chaîne correspondante. 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.

Exceptions

ArgumentNullException

input ou replacement est null.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant remplace les cinq premières occurrences de caractères dupliqués par un seul caractère. Le modèle (\w)\1 d’expression régulière correspond aux occurrences consécutives d’un caractère unique et affecte la première occurrence au premier groupe de capture. Le modèle de $1 remplacement remplace l’intégralité de la correspondance par le premier groupe capturé.

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'

Remarques

La recherche de correspondances commence au début de la input chaîne. L’expression régulière est le modèle défini par le constructeur pour l’objet actif Regex . Si count est négatif, les remplacements continuent jusqu’à la fin de la chaîne. Si count dépasse le nombre de correspondances, toutes les correspondances sont remplacées.

Le replacement paramètre spécifie la chaîne qui doit remplacer les premières count correspondances dans input. replacement peut se composer de n’importe quelle combinaison de texte littéral et de substitutions. Par exemple, le modèle a*${test}b de remplacement insère la chaîne « a* » suivie de la sous-chaîne qui correspond au groupe de capture, le test cas échéant, suivie de la chaîne « b ». Le caractère * n’est pas reconnu comme métacharacteur dans un modèle de remplacement.

Notes

Voir aussi

S’applique à

Replace(String, String)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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.

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

Chaîne dans laquelle une correspondance doit être recherchée.

replacement: String

Chaîne de remplacement.

Retours

String

Exceptions

ArgumentNullException

input ou replacement est null.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant définit une expression régulière, \s+, qui correspond à un ou plusieurs caractères d’espace blanc. La chaîne de remplacement, « », les remplace par un seul caractère d’espace.

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 symbole monétaire de début ou de fin d’une valeur numérique.

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.

Modèle	Description
`\p{Sc}`	Faire correspondre un symbole monétaire. `{Sc}` désigne n’importe quel caractère membre du symbole Unicode, catégorie Devise.
`\s?`	Mettre en correspondance zéro ou un espace blanc.
`(\p{Sc}\s?)?`	Mettre en correspondance zéro ou une occurrence de la combinaison d’un symbole monétaire suivi de zéro ou d’un caractère d’espace blanc. Il s'agit du premier groupe de capture.
`\d+`	Mettre en correspondance un ou plusieurs chiffres décimaux.
`\.?`	Mettre en correspondance zéro ou une occurrence d’un point (utilisé comme caractère séparateur décimal).
`((?<=\.)\d+)?`	Si un point est le caractère précédent, faites correspondre un ou plusieurs chiffres décimaux. Ce modèle peut être mis en correspondance à zéro ou une fois.
`(\d+\.?((?<=\.)\d+)?)`	Correspond au modèle d’un ou plusieurs chiffres décimaux suivis d’un point facultatif et de chiffres décimaux supplémentaires. Il s'agit du deuxième groupe de capture. L’appel à la Replace(String, String) méthode remplace la correspondance entière par la valeur de ce groupe capturé.
`(?(1)\|\s?\p{Sc})?`	Si le premier groupe capturé existe, faites correspondre une chaîne vide. Sinon, faites correspondre zéro ou un caractère d’espace blanc suivi d’un symbole monétaire.

Remarques

La recherche de correspondances commence au début de la input chaîne. L’expression régulière est le modèle défini par le constructeur pour l’objet actif Regex .

Notes

Voir aussi

S’applique à

Replace(String, String, Int32, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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.

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

Chaîne dans laquelle une correspondance doit être recherchée.

replacement: String

Chaîne de remplacement.

count: Int32

Nombre maximal d’occurrences du remplacement.

startat: Int32

Position du caractère dans la chaîne d’entrée où la recherche commence.

Retours

String

Exceptions

ArgumentNullException

input ou replacement est null.

ArgumentOutOfRangeException

startat est inférieur à zéro ou supérieur à la longueur de input.

RegexMatchTimeoutException

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant double espace tous les espaces sauf la première ligne d’une chaîne. Il définit un modèle d’expression régulière, ^.*$, qui correspond à une ligne de texte, appelle la Match(String) méthode pour qu’elle corresponde à la première ligne de la chaîne et utilise les Match.Index propriétés et Match.Count pour déterminer la position de départ de la deuxième ligne.

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.

Modèle	Description
`^`	Correspond au début d’une ligne. (Notez que l’objet Regex a été instancié à l’aide de l’option RegexOptions.Multiline ; sinon, cette classe de caractères correspondrait uniquement au début de la chaîne d’entrée.)
`.*`	Correspond à n’importe quel caractère zéro ou plusieurs fois.
`$`	Correspond à la fin d’une ligne. (Notez que l’objet Regex a été instancié à l’aide de l’option RegexOptions.Multiline ; sinon, cette classe de caractères correspondrait uniquement au début de la chaîne d’entrée.)

La chaîne de remplacement (vbCrLf + "$&" en Visual Basic, "\n$&" en C#) ajoute une nouvelle ligne avant la chaîne correspondante. Notez que \n dans l’exemple C# est interprété comme le caractère newline par le compilateur C#; il ne représente pas une échappement de caractère d’expression régulière.

Remarques

La recherche de correspondances commence dans la input chaîne à la position spécifiée par le startat paramètre . L’expression régulière est le modèle défini par le constructeur pour l’objet actuel Regex . Si count est négatif, les remplacements continuent jusqu’à la fin de la chaîne. Si count dépasse le nombre de correspondances, toutes les correspondances sont remplacées.

Pour plus d’informations sur startat, consultez la section Remarques de Match(String, Int32).

Le replacement paramètre spécifie la chaîne qui doit remplacer chaque correspondance dans input. replacement peut être constitué de n’importe quelle combinaison de texte littéral et de substitutions. Par exemple, le modèle a*${test}b de remplacement insère la chaîne « a* » suivie de la sous-chaîne correspondant au groupe de capture, le test cas échéant, suivie de la chaîne « b ». Le caractère * n’est pas reconnu en tant que métacharacteur dans un modèle de remplacement.

Notes

Les substitutions sont les seuls éléments de langage d’expression régulière reconnus dans un modèle de remplacement. Tous les autres éléments du langage d’expression régulière, y compris les échappements de caractères, sont autorisés uniquement dans les modèles d’expression régulière et ne sont pas reconnus dans les modèles de remplacement.

Voir aussi

S’applique à