Regex.Replace Método

Definição

Em uma cadeia de caracteres de entrada especificada, substitui as cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres de substituição especificada.In a specified input string, replaces strings that match a regular expression pattern with a specified replacement string.

Sobrecargas

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

Em uma cadeia de caracteres de entrada especificada, substitui todas as subcadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado MatchEvaluator.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.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)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Replace(String, MatchEvaluator, Int32, Int32)

Em uma subcadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres retornada por um delegado 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)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. As opções especificadas modificam a operação de correspondência.Specified options modify the matching operation.

Replace(String, String, Int32, Int32)

Em uma subcadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular com uma cadeia de caracteres substituta especificada.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)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. As opções especificadas modificam a operação de correspondência.Specified options modify the matching operation.

Replace(String, String, MatchEvaluator)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado 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)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

Replace(String, String, Int32)

Em uma cadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular com uma cadeia de caracteres substituta especificada.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)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado 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)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres de substituição especificada.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

Replace(String, MatchEvaluator, Int32)

Em uma cadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres retornada por um delegado 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)

Em uma cadeia de caracteres de entrada especificada, substitui todas as subcadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado MatchEvaluator.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

evaluator
MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres correspondida original ou uma cadeia de caracteres de substituição.A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornecem opções para correspondência.A bitwise combination of enumeration values that provide options for matching.

matchTimeout
TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve atingir o tempo limite.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Retornos

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, com exceção de que a cadeia de caracteres de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se pattern não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

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

options não é uma combinação bit a bit válida de valores de RegexOptions.options is not a valid bitwise combination of RegexOptions values.

- ou --or- matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.matchTimeout is negative, zero, or greater than approximately 24 days.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir usa uma expressão regular para extrair as palavras individuais de uma cadeia de caracteres e, em seguida, usa um MatchEvaluator delegado para chamar um método chamado WordScramble que embaralha as letras individuais da palavra.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. Para fazer isso, o método WordScramble cria uma matriz que contém os caracteres na correspondência.To do this, the WordScramble method creates an array that contains the characters in the match. Ele também cria uma matriz paralela que é preenchida com números de ponto flutuante aleatórios.It also creates a parallel array that it populates with random floating-point numbers. As matrizes são classificadas chamando o método Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) e a matriz classificada é fornecida como um argumento para um construtor de classe String.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. Essa cadeia de caracteres recém-criada é retornada pelo método WordScramble.This newly created string is then returned by the WordScramble method. O padrão de expressão regular \w+ corresponde a um ou mais caracteres de palavra; o mecanismo de expressão regular continuará a adicionar caracteres à correspondência até encontrar um caractere diferente de palavra, como um caractere de espaço em branco.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. A chamada para o método Replace(String, String, MatchEvaluator, RegexOptions) inclui a opção RegexOptions.IgnorePatternWhitespace de forma que o comentário no padrão de expressão regular \w+ # Matches all the characters in a word. seja ignorado pelo mecanismo de expressão regular.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

Comentários

O método Regex.Replace(String, String, MatchEvaluator, RegexOptions) é útil para substituir uma correspondência de expressão regular se qualquer uma das seguintes condições for verdadeira:The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Se a cadeia de caracteres de substituição não puder ser prontamente especificada por um padrão de substituição de expressão regular.If the replacement string cannot readily be specified by a regular expression replacement pattern.

  • Se a cadeia de caracteres de substituição resultar de algum processamento executado na cadeia de caracteres correspondente.If the replacement string results from some processing performed on the matched string.

  • Se a cadeia de caracteres de substituição resultar no processamento condicional.If the replacement string results from conditional processing.

O método é equivalente a chamar o método Regex.Matches(String, String, RegexOptions) e passar cada objeto Match na coleção de MatchCollection retornada para o delegado de evaluator.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.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

O parâmetro evaluator é o delegado para um método personalizado que você define e que examina cada correspondência.The evaluator parameter is the delegate for a custom method that you define and that examines each match. O método personalizado deve ter a assinatura a seguir para corresponder ao MatchEvaluator delegado.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

O método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.Your custom method returns a string that replaces the matched input.

Se você especificar RightToLeft para o parâmetro options, a pesquisa de correspondências começará no final da cadeia de caracteres de entrada e se moverá para a esquerda; caso contrário, a pesquisa começa no início da cadeia de caracteres de entrada e se move para a direita.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.

O parâmetro matchTimeout especifica por quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de expirar. A definição de um intervalo de tempo limite impede que expressões regulares que dependem do retrocesso excessivo apareçam para "parar de responder quando processam a entrada que contém correspondências próximas.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. Para obter mais informações, consulte práticas recomendadas para expressões regulares e retrocesso.For more information, see Best Practices for Regular Expressions and Backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método lançará uma exceção de RegexMatchTimeoutException.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Notas aos Chamadores

Recomendamos que você defina o parâmetro matchTimeout para um valor apropriado, como dois segundos.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Se você desabilitar os tempos limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular oferece um desempenho ligeiramente melhor.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. No entanto, você deve desabilitar o tempo limite somente sob as seguintes condições:However, you should disable time-outs only under the following conditions: -Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Isso exclui o texto que foi inserido dinamicamente pelos usuários.This excludes text that has been dynamically input by users.

-Quando o padrão de expressão regular foi totalmente testado para garantir que ele lide com as correspondências, não correspondentes e correspondências próximas.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Quando o padrão de expressão regular não contém nenhum elemento de linguagem que seja conhecido por causar um retrocesso excessivo ao processar uma correspondência próxima.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Veja também

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

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Os parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência é encontrada.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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

replacement
String

A cadeia de caracteres de substituição.The replacement string.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve atingir o tempo limite.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Retornos

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, com exceção de que a cadeia de caracteres de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se pattern não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

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

options não é uma combinação bit a bit válida de valores de RegexOptions.options is not a valid bitwise combination of RegexOptions values.

- ou --or- matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.matchTimeout is negative, zero, or greater than approximately 24 days.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir usa o método Replace(String, String, String, RegexOptions, TimeSpan) para substituir o computador local e os nomes de unidade em um caminho UNC com um caminho de arquivo 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. A expressão regular usa a propriedade Environment.MachineName para incluir o nome do computador local e o método Environment.GetLogicalDrives para incluir os nomes das unidades lógicas.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. Todas as comparações de cadeia de caracteres de expressão regular não diferenciam maiúsculas de minúsculas e qualquer operação de substituição única atinge o tempo limite se uma correspondência não puder ser encontrada em 0,5 segundo.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. Para executar o exemplo com êxito, você deve substituir a cadeia de caracteres literal "mymachine" pelo nome do computador 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

O padrão de expressão regular é definido pela seguinte expressão:The regular expression pattern is defined by the following expression:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.The following table shows how the regular expression pattern is interpreted.

PadrãoPattern DescriçãoDescription
\\\\ Corresponder a dois caracteres de barra invertida consecutivas (\).Match two consecutive backslash (\) characters. Como o caractere de barra invertida é interpretado como o caractere de escape, cada barra invertida deve ter um escape com outra barra invertida.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Corresponder à cadeia de caracteres retornada pela propriedade Environment.MachineName.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Corresponder ao caractere de período (.) seguido por um ou mais caracteres de palavra.Match the period (.) character followed by one or more word characters. Essa correspondência pode ocorrer zero ou mais vezes.This match can occur zero or more times. A subexpressão correspondente não foi capturada.The matched subexpression is not captured.
\\ Corresponder um caractere de barra invertida (\).Match a backslash (\) character.
([" + driveNames + "]) Corresponder à classe de caractere que consiste nas letras de unidade individuais.Match the character class that consists of the individual drive letters. Essa correspondência é a primeira subexpressão capturada.This match is the first captured subexpression.
\$ Corresponder ao caractere de sinal de dólar literal ($).Match the literal dollar sign ($) character.

O padrão de substituição $1 substitui a correspondência inteira pela primeira subexpressão capturada.The replacement pattern $1 replaces the entire match with the first captured subexpression. Ou seja, ele substitui o computador UNC e o nome da unidade pela letra da unidade.That is, it replaces the UNC machine and drive name with the drive letter.

Comentários

Os métodos de Replace estáticos são equivalentes à construção de um objeto de Regex com o padrão de expressão regular especificado e à chamada do método de instância Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Se você especificar RightToLeft para o parâmetro options, a pesquisa de correspondências começará no final da cadeia de caracteres de entrada e se moverá para a esquerda; caso contrário, a pesquisa começa no início da cadeia de caracteres de entrada e se move para a direita.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.

O parâmetro replacement especifica a cadeia de caracteres que deve substituir cada correspondência em input.The replacement parameter specifies the string that is to replace each match in input. replacement pode consistir em qualquer combinação de texto literal e substituições.replacement can consist of any combination of literal text and substitutions. Por exemplo, o padrão de substituição a*${test}b insere a cadeia de caracteres "a *" seguida da subcadeia de caracteres que corresponde ao grupo de captura test, se houver, seguido pela cadeia de caracteres "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". O caractere * não é reconhecido como um metacaractere dentro de um padrão de substituição.The * character is not recognized as a metacharacter within a replacement pattern.

Observação

As substituições são os únicos elementos de linguagem de expressão regular que são reconhecidos em um padrão de substituição.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos os outros elementos de linguagem de expressão regular, incluindo escapes de caractere, são permitidos somente em padrões de expressão regulares e não são reconhecidos em padrões de substituição.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

O parâmetro matchTimeout especifica por quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de expirar. A definição de um intervalo de tempo limite impede que expressões regulares que dependem de retrocesso excessivo apareçam para parar de responder quando processam a entrada que contém correspondências próximas.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. Para obter mais informações, consulte práticas recomendadas para expressões regulares e retrocesso.For more information, see Best Practices for Regular Expressions and Backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método lançará uma exceção de RegexMatchTimeoutException.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Notas aos Chamadores

Recomendamos que você defina o parâmetro matchTimeout para um valor apropriado, como dois segundos.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Se você desabilitar os tempos limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular oferece um desempenho ligeiramente melhor.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. No entanto, você deve desabilitar o tempo limite somente sob as seguintes condições:However, you should disable time-outs only under the following conditions: -Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Isso exclui o texto que foi inserido dinamicamente pelos usuários.This excludes text that has been dynamically input by users.

-Quando o padrão de expressão regular foi totalmente testado para garantir que ele lide com as correspondências, não correspondentes e correspondências próximas.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Quando o padrão de expressão regular não contém nenhum elemento de linguagem que seja conhecido por causar um retrocesso excessivo ao processar uma correspondência próxima.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Veja também

Replace(String, MatchEvaluator, Int32, Int32)

Em uma subcadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres retornada por um delegado 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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

evaluator
MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres correspondida original ou uma cadeia de caracteres de substituição.A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32

O número máximo de vezes que a substituição ocorrerá.The maximum number of times the replacement will occur.

startat
Int32

A posição do caractere na cadeia de caracteres de entrada na qual a pesquisa começa.The character position in the input string where the search begins.

Retornos

Uma nova cadeia de caracteres é idêntica à cadeia de entrada, com exceção de que a cadeia de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se o padrão de expressão regular não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

input ou evaluator é null.input or evaluator is null.

startat é menor que zero ou maior que o tamanho de input.startat is less than zero or greater than the length of input.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Comentários

O método Regex.Replace(String, MatchEvaluator, Int32, Int32) é útil para substituir uma correspondência de expressão regular se qualquer uma das seguintes condições for verdadeira:The Regex.Replace(String, MatchEvaluator, Int32, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.The replacement string results from some processing done on the matched string.

  • A cadeia de caracteres de substituição resulta do processamento condicional.The replacement string results from conditional processing.

O método é equivalente a chamar o método Regex.Matches(String, Int32) e passar o primeiro countMatch objetos na coleção de MatchCollection retornada para o delegado evaluator.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.

A expressão regular é o padrão definido pelo construtor para o objeto de Regex atual.The regular expression is the pattern defined by the constructor for the current Regex object.

O parâmetro evaluator é o delegado para um método personalizado que você define e que examina cada correspondência.The evaluator parameter is the delegate for a custom method that you define and that examines each match. O método personalizado deve ter a assinatura a seguir para corresponder ao MatchEvaluator delegado.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

O método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.Your custom method returns a string that replaces the matched input.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).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. Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto de Regex é criado.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. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf 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

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Veja também

Replace(String, String, MatchEvaluator, RegexOptions)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado MatchEvaluator.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. As opções especificadas modificam a operação de correspondência.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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

evaluator
MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres correspondida original ou uma cadeia de caracteres de substituição.A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.A bitwise combination of the enumeration values that provide options for matching.

Retornos

Uma nova cadeia de caracteres é idêntica à cadeia de entrada, com exceção de que a cadeia de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se pattern não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

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

options não é uma combinação bit a bit válida de valores de RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir usa uma expressão regular para extrair as palavras individuais de uma cadeia de caracteres e, em seguida, usa um MatchEvaluator delegado para chamar um método chamado WordScramble que embaralha as letras individuais da palavra.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. Para fazer isso, o método WordScramble cria uma matriz que contém os caracteres na correspondência.To do this, the WordScramble method creates an array that contains the characters in the match. Ele também cria uma matriz paralela que é preenchida com números de ponto flutuante aleatórios.It also creates a parallel array that it populates with random floating-point numbers. As matrizes são classificadas chamando o método Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) e a matriz classificada é fornecida como um argumento para um construtor de classe String.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. Essa cadeia de caracteres recém-criada é retornada pelo método WordScramble.This newly created string is then returned by the WordScramble method. O padrão de expressão regular \w+ corresponde a um ou mais caracteres de palavra; o mecanismo de expressão regular continuará a adicionar caracteres à correspondência até encontrar um caractere diferente de palavra, como um caractere de espaço em branco.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. A chamada para o método Replace(String, String, MatchEvaluator, RegexOptions) inclui a opção RegexOptions.IgnorePatternWhitespace de forma que o comentário no padrão de expressão regular \w+ # Matches all the characters in a word. seja ignorado pelo mecanismo de expressão regular.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

Comentários

O método Regex.Replace(String, String, MatchEvaluator, RegexOptions) é útil para substituir uma correspondência de expressão regular em se qualquer uma das seguintes condições for verdadeira: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:

  • A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.The replacement string results from some processing done on the matched string.

  • A cadeia de caracteres de substituição resulta do processamento condicional.The replacement string results from conditional processing.

O método é equivalente a chamar o método Regex.Matches(String, String, RegexOptions) e passar cada objeto Match na coleção de MatchCollection retornada para o delegado de evaluator.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.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

O parâmetro evaluator é o delegado para um método personalizado que você define e que examina cada correspondência.The evaluator parameter is the delegate for a custom method that you define and that examines each match. O método personalizado deve ter a assinatura a seguir para corresponder ao MatchEvaluator delegado.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

O método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.Your custom method returns a string that replaces the matched input.

Se você especificar RightToLeft para o parâmetro options, a pesquisa de correspondências começará no final da cadeia de caracteres de entrada e se moverá para a esquerda; caso contrário, a pesquisa começa no início da cadeia de caracteres de entrada e se move para a direita.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.

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado.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. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançada.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.

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Veja também

Replace(String, String, Int32, Int32)

Em uma subcadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular com uma cadeia de caracteres substituta especificada.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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

replacement
String

A cadeia de caracteres de substituição.The replacement string.

count
Int32

Número máximo de vezes que a substituição pode ocorrer.Maximum number of times the replacement can occur.

startat
Int32

A posição do caractere na cadeia de caracteres de entrada na qual a pesquisa começa.The character position in the input string where the search begins.

Retornos

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, com exceção de que a cadeia de caracteres de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se o padrão de expressão regular não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

input ou replacement é null.input or replacement is null.

startat é menor que zero ou maior que o tamanho de input.startat is less than zero or greater than the length of input.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir tem dois espaços duplos, exceto a primeira linha de uma cadeia de caracteres.The following example double-spaces all but the first line of a string. Ele define um padrão de expressão regular, ^.*$, que corresponde a uma linha de texto, chama o método Match(String) para corresponder à primeira linha da cadeia de caracteres e usa as propriedades Match.Index e Match.Count para determinar a posição inicial da segunda linha.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.

O padrão de expressão regular ^.*$ é definido conforme mostrado na tabela a seguir.The regular expression pattern ^.*$ is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
^ Corresponder ao início de uma linha.Match the start of a line. (Observe que o objeto Regex foi instanciado usando a opção RegexOptions.Multiline; caso contrário, essa classe de caractere só corresponderia ao início da cadeia de caracteres de entrada.)(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.)
.* Corresponder qualquer caractere zero ou mais vezes.Match any character zero or more times.
$ Corresponde ao fim de uma linha.Match the end of a line. (Observe que o objeto Regex foi instanciado usando a opção RegexOptions.Multiline; caso contrário, essa classe de caractere só corresponderia ao início da cadeia de caracteres de entrada.)(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.)

A cadeia de caracteres de substituição (vbCrLf + "$&" em Visual Basic C#, "\n$&" em) adiciona uma nova linha antes da cadeia de caracteres correspondente.The replacement string (vbCrLf + "$&" in Visual Basic, "\n$&" in C#) adds a new line before the matched string. Observe que \n no C# exemplo é interpretado como o caractere de Nova C# linha pelo compilador; Ele não representa um escape de caractere de expressão regular.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.

Comentários

A pesquisa de correspondências começa na cadeia de caracteres input na posição especificada pelo parâmetro startat.The search for matches starts in the input string at the position specified by the startat parameter. A expressão regular é o padrão definido pelo construtor para o objeto de Regex atual.The regular expression is the pattern defined by the constructor for the current Regex object. Se count for negativo, as substituições continuarão no final da cadeia de caracteres.If count is negative, replacements continue to the end of the string. Se count exceder o número de correspondências, todas as correspondências serão substituídas.If count exceeds the number of matches, all matches are replaced.

O parâmetro replacement especifica a cadeia de caracteres que deve substituir cada correspondência em input.The replacement parameter specifies the string that is to replace each match in input. replacement pode consistir em qualquer combinação de texto literal e substituições.replacement can consist of any combination of literal text and substitutions. Por exemplo, o padrão de substituição a*${test}b insere a cadeia de caracteres "a *" seguida da subcadeia de caracteres que corresponde ao grupo de captura test, se houver, seguido pela cadeia de caracteres "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". O caractere * não é reconhecido como um metacaractere dentro de um padrão de substituição.The * character is not recognized as a metacharacter within a replacement pattern.

Observação

As substituições são os únicos elementos de linguagem de expressão regular que são reconhecidos em um padrão de substituição.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos os outros elementos de linguagem de expressão regular, incluindo escapes de caractere, são permitidos somente em padrões de expressão regulares e não são reconhecidos em padrões de substituição.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).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. Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto de Regex é criado.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. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf 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

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Veja também

Replace(String, String, String, RegexOptions)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. As opções especificadas modificam a operação de correspondência.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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

replacement
String

A cadeia de caracteres de substituição.The replacement string.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.A bitwise combination of the enumeration values that provide options for matching.

Retornos

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, com exceção de que a cadeia de caracteres de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se pattern não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

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

options não é uma combinação bit a bit válida de valores de RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir usa o método Replace(String, String, String, RegexOptions) para substituir o computador local e os nomes de unidade em um caminho UNC com um caminho de arquivo 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. A expressão regular usa a propriedade Environment.MachineName para incluir o nome do computador local e o método Environment.GetLogicalDrives para incluir os nomes das unidades lógicas.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. Todas as comparações de cadeia de caracteres de expressão regular diferenciam maiúsculas de minúsculas.All regular expression string comparisons are case-insensitive. Para executar o exemplo com êxito, você deve substituir a cadeia de caracteres literal "mymachine" pelo nome do computador 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

O padrão de expressão regular é definido pela seguinte expressão:The regular expression pattern is defined by the following expression:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.The following table shows how the regular expression pattern is interpreted.

PadrãoPattern DescriçãoDescription
\\\\ Corresponder a dois caracteres de barra invertida consecutivas (\).Match two consecutive backslash (\) characters. Como o caractere de barra invertida é interpretado como o caractere de escape, cada barra invertida deve ter um escape com outra barra invertida.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Corresponder à cadeia de caracteres retornada pela propriedade Environment.MachineName.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Corresponder ao caractere de período (.) seguido por um ou mais caracteres de palavra.Match the period (.) character followed by one or more word characters. Essa correspondência pode ocorrer zero ou mais vezes.This match can occur zero or more times. A subexpressão correspondente não foi capturada.The matched subexpression is not captured.
\\ Corresponder um caractere de barra invertida (\).Match a backslash (\) character.
([" + driveNames + "]) Corresponder à classe de caractere que consiste nas letras de unidade individuais.Match the character class that consists of the individual drive letters. Essa correspondência é a primeira subexpressão capturada.This match is the first captured subexpression.
\$ Corresponder ao caractere de sinal de dólar literal ($).Match the literal dollar sign ($) character.

O padrão de substituição $1 substitui a correspondência inteira pela primeira subexpressão capturada.The replacement pattern $1 replaces the entire match with the first captured subexpression. Ou seja, ele substitui o computador UNC e o nome da unidade pela letra da unidade.That is, it replaces the UNC machine and drive name with the drive letter.

Comentários

Os métodos de Replace estáticos são equivalentes à construção de um objeto de Regex com o padrão de expressão regular especificado e à chamada do método de instância Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Se você especificar RightToLeft para o parâmetro options, a pesquisa de correspondências começará no final da cadeia de caracteres de entrada e se moverá para a esquerda; caso contrário, a pesquisa começa no início da cadeia de caracteres de entrada e se move para a direita.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.

O parâmetro replacement especifica a cadeia de caracteres que deve substituir cada correspondência em input.The replacement parameter specifies the string that is to replace each match in input. replacement pode consistir em qualquer combinação de texto literal e substituições.replacement can consist of any combination of literal text and substitutions. Por exemplo, o padrão de substituição a*${test}b insere a cadeia de caracteres "a *" seguida da subcadeia de caracteres que corresponde ao grupo de captura test, se houver, seguido pela cadeia de caracteres "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". O caractere * não é reconhecido como um metacaractere dentro de um padrão de substituição.The * character is not recognized as a metacharacter within a replacement pattern.

Observação

As substituições são os únicos elementos de linguagem de expressão regular que são reconhecidos em um padrão de substituição.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos os outros elementos de linguagem de expressão regular, incluindo escapes de caractere, são permitidos somente em padrões de expressão regulares e não são reconhecidos em padrões de substituição.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado.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. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançada.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.

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo que é igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado.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. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede o tempo limite do método, será usado.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. O método estático recomendado para substituir uma correspondência de padrão é Replace(String, String, String, RegexOptions, TimeSpan), o que permite que você defina o intervalo de tempo limite.The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Veja também

Replace(String, String, MatchEvaluator)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado 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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

evaluator
MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres correspondida original ou uma cadeia de caracteres de substituição.A custom method that examines each match and returns either the original matched string or a replacement string.

Retornos

Uma nova cadeia de caracteres é idêntica à cadeia de entrada, com exceção de que a cadeia de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se pattern não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

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

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir usa uma expressão regular para extrair as palavras individuais de uma cadeia de caracteres e, em seguida, usa um MatchEvaluator delegado para chamar um método chamado WordScramble que embaralha as letras individuais da palavra.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. Para fazer isso, o método WordScramble cria uma matriz que contém os caracteres na correspondência.To do this, the WordScramble method creates an array that contains the characters in the match. Ele também cria uma matriz paralela que é preenchida com números de ponto flutuante aleatórios.It also creates a parallel array that it populates with random floating-point numbers. As matrizes são classificadas chamando o método Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) e a matriz classificada é fornecida como um argumento para um construtor de classe String.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. Essa cadeia de caracteres recém-criada é retornada pelo método WordScramble.This newly created string is then returned by the WordScramble method. O padrão de expressão regular \w+ corresponde a um ou mais caracteres de palavra; o mecanismo de expressão regular continuará a adicionar caracteres à correspondência até encontrar um caractere diferente de palavra, como um caractere de espaço em branco.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

Comentários

O método Regex.Replace(String, String, MatchEvaluator) é útil para substituir uma correspondência de expressão regular se qualquer uma das seguintes condições for verdadeira:The Regex.Replace(String, String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.The replacement string results from some processing done on the matched string.

  • A cadeia de caracteres de substituição resulta do processamento condicional.The replacement string results from conditional processing.

O método é equivalente a chamar o método Regex.Matches(String, String) e passar cada objeto Match na coleção de MatchCollection retornada para o delegado de evaluator.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.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

O parâmetro evaluator é o delegado para um método personalizado que você define e que examina cada correspondência.The evaluator parameter is the delegate for a custom method that you define and that examines each match. O método personalizado deve ter a assinatura a seguir para corresponder ao MatchEvaluator delegado.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

O método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.Your custom method returns a string that replaces the matched input.

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado.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. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançada.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.

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo que é igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado.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. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede o tempo limite do método, será usado.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. O método estático recomendado para avaliar e substituir uma correspondência de padrão é Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), o que permite que você defina o intervalo de tempo limite.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.

Veja também

Replace(String, String, String)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres de substituição especificada.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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

replacement
String

A cadeia de caracteres de substituição.The replacement string.

Retornos

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, com exceção de que a cadeia de caracteres de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se pattern não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

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

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir define uma expressão regular, \s+, que corresponde a um ou mais caracteres de espaço em branco.The following example defines a regular expression, \s+, that matches one or more white-space characters. A cadeia de caracteres de substituição, "", substitui-as por um caractere de espaço único.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.

O exemplo a seguir usa o método Replace(String, String, String) para substituir o computador local e os nomes de unidade em um caminho UNC com um caminho de arquivo 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. A expressão regular usa a propriedade Environment.MachineName para incluir o nome do computador local e o método Environment.GetLogicalDrives para incluir os nomes das unidades lógicas.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. Para executar o exemplo com êxito, você deve substituir a cadeia de caracteres literal "mymachine" pelo nome do computador 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

O padrão de expressão regular é definido pela seguinte expressão:The regular expression pattern is defined by the following expression:

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

A tabela a seguir mostra como o padrão da expressão regular é interpretado.The following table shows how the regular expression pattern is interpreted.

PadrãoPattern DescriçãoDescription
\\\\ Corresponder a dois caracteres de barra invertida consecutivas (\).Match two consecutive backslash (\) characters. Como o caractere de barra invertida é interpretado como o caractere de escape, cada barra invertida deve ter um escape com outra barra invertida.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
(?i:" + Environment.MachineName + ") Execute uma correspondência que não diferencia maiúsculas de minúsculas da cadeia de caracteres retornada pela propriedade Environment.MachineName.Perform a case-insensitive match of the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Corresponder ao caractere de período (.) seguido por um ou mais caracteres de palavra.Match the period (.) character followed by one or more word characters. Essa correspondência pode ocorrer zero ou mais vezes.This match can occur zero or more times. A subexpressão correspondente não foi capturada.The matched subexpression is not captured.
\\ Corresponder um caractere de barra invertida (\).Match a backslash (\) character.
((?i:[" + driveNames + "])) Execute uma correspondência que não diferencia maiúsculas de minúsculas da classe Character que consiste nas letras da unidade individuais.Perform a case-insensitive match of the character class that consists of the individual drive letters. Essa correspondência é a primeira subexpressão capturada.This match is the first captured subexpression.
\$ Corresponder ao caractere de sinal de dólar literal ($).Match the literal dollar sign ($) character.

O padrão de substituição $1 substitui a correspondência inteira pela primeira subexpressão capturada.The replacement pattern $1 replaces the entire match with the first captured subexpression. Ou seja, ele substitui o computador UNC e o nome da unidade pela letra da unidade.That is, it replaces the UNC machine and drive name with the drive letter.

Comentários

Os métodos de Replace estáticos são equivalentes à construção de um objeto de Regex com o padrão de expressão regular especificado e à chamada do método de instância Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. A pesquisa de correspondências começa no início da cadeia de caracteres de input.The search for matches starts at the beginning of the input string.

O parâmetro replacement especifica a cadeia de caracteres que deve substituir cada correspondência em input.The replacement parameter specifies the string that is to replace each match in input. replacement pode consistir em qualquer combinação de texto literal e substituições.replacement can consist of any combination of literal text and substitutions. Por exemplo, o padrão de substituição a*${test}b insere a cadeia de caracteres "a *" seguida da subcadeia de caracteres que corresponde ao grupo de captura test, se houver, seguido pela cadeia de caracteres "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". O caractere * não é reconhecido como um metacaractere dentro de um padrão de substituição.The * character is not recognized as a metacharacter within a replacement pattern.

Observação

As substituições são os únicos elementos de linguagem de expressão regular que são reconhecidos em um padrão de substituição.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos os outros elementos de linguagem de expressão regular, incluindo escapes de caractere, são permitidos somente em padrões de expressão regulares e não são reconhecidos em padrões de substituição.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado.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. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançada.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.

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo que é igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado.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. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede o tempo limite do método, será usado.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. O método estático recomendado para substituir uma correspondência de padrão é Replace(String, String, String, RegexOptions, TimeSpan), o que permite que você defina o intervalo de tempo limite.The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Veja também

Replace(String, String, Int32)

Em uma cadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular com uma cadeia de caracteres substituta especificada.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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

replacement
String

A cadeia de caracteres de substituição.The replacement string.

count
Int32

O número máximo de vezes que a substituição pode ocorrer.The maximum number of times the replacement can occur.

Retornos

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, com exceção de que a cadeia de caracteres de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se o padrão de expressão regular não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

input ou replacement é null.input or replacement is null.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir substitui as cinco primeiras ocorrências de caracteres duplicados por um único caractere.The following example replaces the first five occurrences of duplicated characters with a single character. O padrão de expressão regular (\w)\1 corresponde a ocorrências consecutivas de um único caractere e atribui a primeira ocorrência ao primeiro grupo de captura.The regular expression pattern (\w)\1 matches consecutive occurrences of a single character and assigns the first occurrence to the first capturing group. O padrão de substituição $1 substitui a correspondência inteira pelo primeiro grupo capturado.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'

Comentários

A pesquisa de correspondências começa no início da cadeia de caracteres de input.The search for matches starts at the beginning of the input string. A expressão regular é o padrão definido pelo construtor para o objeto de Regex atual.The regular expression is the pattern that is defined by the constructor for the current Regex object. Se count for negativo, as substituições continuarão no final da cadeia de caracteres.If count is negative, replacements continue to the end of the string. Se count exceder o número de correspondências, todas as correspondências serão substituídas.If count exceeds the number of matches, all matches are replaced.

O parâmetro replacement especifica a cadeia de caracteres que deve substituir as primeiras count correspondências no input.The replacement parameter specifies the string that is to replace the first count matches in input. replacement pode consistir em qualquer combinação de texto literal e substituições.replacement can consist of any combination of literal text and substitutions. Por exemplo, o padrão de substituição a*${test}b insere a cadeia de caracteres "a *" seguida da subcadeia de caracteres que corresponde ao grupo de captura test, se houver, seguido pela cadeia de caracteres "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". O caractere * não é reconhecido como um metacaractere dentro de um padrão de substituição.The * character is not recognized as a metacharacter within a replacement pattern.

Observação

As substituições são os únicos elementos de linguagem de expressão regular que são reconhecidos em um padrão de substituição.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos os outros elementos de linguagem de expressão regular, incluindo escapes de caractere, são permitidos somente em padrões de expressão regulares e não são reconhecidos em padrões de substituição.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).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. Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto de Regex é criado.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. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf 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

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Veja também

Replace(String, MatchEvaluator)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a uma expressão regular especificada por uma cadeia de caracteres retornada por um delegado 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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

evaluator
MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres correspondida original ou uma cadeia de caracteres de substituição.A custom method that examines each match and returns either the original matched string or a replacement string.

Retornos

Uma nova cadeia de caracteres é idêntica à cadeia de entrada, com exceção de que a cadeia de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se o padrão de expressão regular não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

input ou evaluator é null.input or evaluator is null.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo de código a seguir exibe uma cadeia de caracteres original, corresponde a cada palavra na cadeia de caracteres original, converte o primeiro caractere de cada correspondência em maiúsculas e, em seguida, exibe a cadeia de caracteres convertida.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]

Comentários

O método Regex.Replace(String, MatchEvaluator) é útil para substituir uma correspondência de expressão regular se qualquer uma das seguintes condições for verdadeira:The Regex.Replace(String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.The replacement string results from some processing done on the matched string.

  • A cadeia de caracteres de substituição resulta do processamento condicional.The replacement string results from conditional processing.

O método é equivalente a chamar o método Regex.Matches(String) e passar cada objeto Match na coleção de MatchCollection retornada para o delegado de evaluator.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.

A expressão regular é o padrão definido pelo construtor para o objeto de Regex atual.The regular expression is the pattern defined by the constructor for the current Regex object.

O parâmetro evaluator é o delegado para um método personalizado que você define e que examina cada correspondência.The evaluator parameter is the delegate for a custom method that you define and that examines each match. O método personalizado deve ter a assinatura a seguir para corresponder ao MatchEvaluator delegado.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

O método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.Your custom method returns a string that replaces the matched input.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).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. Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto de Regex é criado.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. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf 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

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Veja também

Replace(String, String)

Em uma cadeia de caracteres de entrada especificada, substitui todas as cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres de substituição especificada.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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

replacement
String

A cadeia de caracteres de substituição.The replacement string.

Retornos

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, com exceção de que a cadeia de caracteres de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Se o padrão de expressão regular não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

input ou replacement é null.input or replacement is null.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir define uma expressão regular, \s+, que corresponde a um ou mais caracteres de espaço em branco.The following example defines a regular expression, \s+, that matches one or more white-space characters. A cadeia de caracteres de substituição, "", substitui-as por um caractere de espaço único.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.

O exemplo a seguir define uma expressão regular, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?e um padrão de substituição, $2, que remove um símbolo de moeda à esquerda ou à direita de um valor numérico.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'

A expressão regular é interpretada conforme mostrado na tabela a seguir.The regular expression is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
\p{Sc} Corresponde a um símbolo de moeda.Match a currency symbol. {Sc} denota qualquer caractere que seja membro do símbolo Unicode, da categoria de moeda.{Sc} denotes any character that is a member of the Unicode Symbol, Currency category.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space character.
(\p{Sc}\s?)? Corresponder a zero ou uma ocorrência da combinação de um símbolo de moeda seguido por zero ou um caractere de espaço em branco.Match zero or one occurrence of the combination of a currency symbol followed by zero or one white-space character. Este é o primeiro grupo de captura.This is the first capturing group.
\d+ Corresponde a um ou mais dígitos decimais.Match one or more decimal digits.
\.? Corresponder a zero ou uma ocorrência de um ponto (usado como um caractere separador decimal).Match zero or one occurrence of a period (used as a decimal separator character).
((?<=\.)\d+)? Se um ponto for o caractere anterior, corresponda a um ou mais dígitos decimais.If a period is the previous character, match one or more decimal digits. Esse padrão pode corresponder a zero ou uma vez.This pattern can be matched either zero or one time.
(\d+\.?((?<=\.)\d+)?) Corresponder o padrão de um ou mais dígitos decimais seguidos por um período opcional e dígitos decimais adicionais.Match the pattern of one or more decimal digits followed by an optional period and additional decimal digits. Este é o segundo grupo de captura.This is the second capturing group. A chamada para o método Replace(String, String) substitui toda a correspondência pelo valor desse grupo capturado.The call to the Replace(String, String) method replaces the entire match with the value of this captured group.
(?(1)|\s?\p{Sc})? Se o primeiro grupo capturado existir, corresponda a uma cadeia de caracteres vazia.If the first captured group exists, match an empty string. Caso contrário, corresponda a zero ou um caractere de espaço em branco seguido de um símbolo de moeda.Otherwise, match zero or one white-space character followed by a currency symbol.

Comentários

A pesquisa de correspondências começa no início da cadeia de caracteres de input.The search for matches starts at the beginning of the input string. A expressão regular é o padrão definido pelo construtor para o objeto de Regex atual.The regular expression is the pattern defined by the constructor for the current Regex object.

O parâmetro replacement especifica a cadeia de caracteres que deve substituir cada correspondência em input.The replacement parameter specifies the string that is to replace each match in input. replacement pode consistir em qualquer combinação de texto literal e substituições.replacement can consist of any combination of literal text and substitutions. Por exemplo, o padrão de substituição a*${test}b insere a cadeia de caracteres "a *" seguida da subcadeia de caracteres que corresponde ao grupo de captura test, se houver, seguido pela cadeia de caracteres "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". O caractere * não é reconhecido como um metacaractere dentro de um padrão de substituição.The * character is not recognized as a metacharacter within a replacement pattern.

Observação

As substituições são os únicos elementos de linguagem de expressão regular que são reconhecidos em um padrão de substituição.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos os outros elementos de linguagem de expressão regular, incluindo escapes de caractere, são permitidos somente em padrões de expressão regulares e não são reconhecidos em padrões de substituição.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).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. Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto de Regex é criado.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. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf 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

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Veja também

Replace(String, MatchEvaluator, Int32)

Em uma cadeia de caracteres de entrada especificada, substitui um número máximo especificado de cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres retornada por um delegado 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

Parâmetros

input
String

A cadeia de caracteres na qual será pesquisada uma correspondência.The string to search for a match.

evaluator
MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres correspondida original ou uma cadeia de caracteres de substituição.A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32

O número máximo de vezes que a substituição ocorrerá.The maximum number of times the replacement will occur.

Retornos

Uma nova cadeia de caracteres é idêntica à cadeia de entrada, com exceção de que a cadeia de substituição substitui cada cadeia de caracteres correspondente.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Se o padrão de expressão regular não tiver uma correspondência na instância atual, o método retornará a instância atual inalterada.If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceções

input ou evaluator é null.input or evaluator is null.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir usa uma expressão regular para deliberadamente a metade das palavras de uma lista.The following example uses a regular expression to deliberately misspell half of the words in a list. Ele usa a expressão regular \w*(ie|ei)\w* para corresponder palavras que incluem os caracteres "IE" ou "Ei".It uses the regular expression \w*(ie|ei)\w* to match words that include the characters "ie" or "ei". Ele passa a primeira metade das palavras correspondentes para o método ReverseLetter, que, por sua vez, usa o método Replace(String, String, String, RegexOptions) para reverter "i" e "e" na cadeia de caracteres correspondente.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. As palavras restantes permanecem inalteradas.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

A expressão regular \w*(ie|ei)\w* é definida conforme mostrado na tabela a seguir.The regular expression \w*(ie|ei)\w* is defined as shown in the following table.

PadrãoPattern DescriçãoDescription
\w* Corresponder a zero ou mais caracteres de palavra.Match zero or more word characters.
(ie|ei) Corresponder a "IE" ou "Ei".Match either "ie" or "ei".
\w* Corresponder a zero ou mais caracteres de palavra.Match zero or more word characters.

O padrão de expressão regular ([ie])([ie]) no método ReverseLetter corresponde ao primeiro "i" ou "e" no diphthong "IE" ou "Ei" e atribui a letra ao primeiro grupo de captura.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. Ele corresponde ao segundo "i" ou "e" e atribui a letra ao segundo grupo de captura.It matches the second "i" or "e" and assigns the letter to the second capturing group. Os dois caracteres são então revertidos chamando o método Replace(String, String, String) com o $2$1padrão de substituição.The two characters are then reversed by calling the Replace(String, String, String) method with the replacement pattern $2$1.

Comentários

O método Regex.Replace(String, MatchEvaluator, Int32) é útil para substituir uma correspondência de expressão regular se qualquer uma das seguintes condições for verdadeira:The Regex.Replace(String, MatchEvaluator, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.The replacement string results from some processing done on the matched string.

  • A cadeia de caracteres de substituição resulta do processamento condicional.The replacement string results from conditional processing.

O método é equivalente a chamar o método Regex.Matches(String) e passar o primeiro countMatch objetos na coleção de MatchCollection retornada para o delegado evaluator.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.

A expressão regular é o padrão definido pelo construtor para o objeto de Regex atual.The regular expression is the pattern defined by the constructor for the current Regex object.

O parâmetro evaluator é o delegado para um método personalizado que você define e que examina cada correspondência.The evaluator parameter is the delegate for a custom method that you define and that examines each match. O método personalizado deve ter a assinatura a seguir para corresponder ao MatchEvaluator delegado.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

O método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.Your custom method returns a string that replaces the matched input.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de substituição exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).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. Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto de Regex é criado.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. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançadaIf 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

Como o método retorna input inalterado se não houver correspondência, você poderá usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.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.

Veja também

Aplica-se a