Regex.Replace Método

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Em uma cadeia de caracteres de entrada especificada, substitui cadeias de caracteres que correspondem a um padrão de expressão regular por uma cadeia de caracteres de substituição especificada.

Sobrecargas

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 com uma cadeia de caracteres retornada por um delegado de MatchEvaluator.
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.
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. Parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência for encontrada.
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. As opções especificadas modificam a operação de correspondência.
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. Parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência for encontrada.
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. As opções especificadas modificam a operação de correspondência.
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.
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 com uma cadeia de caracteres retornada por um delegado MatchEvaluator.
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.
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 de substituição especificada.
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.
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 de substituição especificada.

Replace(String, MatchEvaluator, Int32, Int32)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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 retornada por um delegado de MatchEvaluator.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String

Parâmetros

input: String

A cadeia de caracteres a ser pesquisada por uma correspondência.

evaluator: MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres original correspondente ou uma cadeia de caracteres de substituição.

count: Int32

O número máximo de vezes que a substituição ocorrerá.

startat: Int32

A posição do caractere na cadeia de caracteres de entrada em que a pesquisa começa.

Retornos

String

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, exceto que uma cadeia de caracteres de substituição assume o lugar de cada cadeia de caracteres correspondente. Se o padrão de expressão regular não for correspondido na instância atual, o método retornará a instância atual inalterada.

Exceções

ArgumentNullException

input ou evaluator é null.

ArgumentOutOfRangeException

startat é menor que zero ou maior que o comprimento de input.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

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:

A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.
A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.
A cadeia de caracteres de substituição resulta do processamento condicional.

O método é equivalente a chamar o método Regex.Matches(String, Int32) e passar os primeiros objetos countMatch na coleção MatchCollection retornada para o delegado evaluator.

Para obter mais detalhes sobre startat, consulte a seção Comentários do Match(String, Int32).

A expressão regular é o padrão definido pelo construtor para o objeto Regex atual.

O parâmetro evaluator é o delegado de um método personalizado que você define e que examina cada correspondência. O método personalizado deve ter a assinatura a seguir para corresponder ao delegado MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Seu método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.

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 pelo construtor Regex.Regex(String, RegexOptions, TimeSpan). 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 Regex é criado. Se nenhum tempo limite for definido na chamada do construtor Regex ou nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada

Como o método retorna input inalterado se não houver correspondência, você pode usar o método Object.ReferenceEquals para determinar se o método fez substituições na cadeia de caracteres de entrada.

Confira também

MatchEvaluator
substituições em expressões regulares
linguagem de expressão regular – referência rápida

Aplica-se a

Replace(String, String, String)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

replacement: String

A cadeia de caracteres de substituição.

Retornos

String

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, exceto que a cadeia de caracteres de substituição assume o lugar de cada cadeia de caracteres correspondente. Se pattern não for correspondido na instância atual, o método retornará a instância atual inalterada.

Exceções

ArgumentException

Ocorreu um erro de análise de expressão regular.

ArgumentNullException

input, patternou replacement é null.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

O exemplo a seguir define uma expressão regular, \s+, que corresponde a um ou mais caracteres de espaço em branco. A cadeia de caracteres de substituição, "", substitui-as por um único caractere de espaço.

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 por um caminho de arquivo local. 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. Para executar o exemplo com êxito, substitua a cadeia de caracteres literal "MyMachine" pelo nome do computador local.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\(?i:" + Environment.MachineName + @")(?:\.\w+)*\\((?i:[" + driveNames + @"]))\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

O padrão de expressão regular é definido pela seguinte expressão:

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

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Padrão	Descrição
`\\\\`	Corresponde a dois caracteres de barra invertida consecutiva (`\`). Como o caractere de barra invertida é interpretado como o caractere de escape, cada barra invertida deve ser escapada com outra barra invertida.
`(?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.
`(?:\.\w+)*`	Corresponde ao caractere de período (`.`) seguido por um ou mais caracteres de palavra. Essa correspondência pode ocorrer zero ou mais vezes. A subexpressão correspondente não é capturada.
`\\`	Corresponder a um caractere de barra invertida (`\`).
`((?i:[" + driveNames + "]))`	Execute uma correspondência que não diferencia maiúsculas de minúsculas da classe de caractere que consiste nas letras de unidade individuais. Essa correspondência é a primeira subexpressão capturada.
`\$`	Corresponda ao caractere de sinal de dólar literal (`$`).

O padrão de substituição $1 substitui toda a correspondência pela primeira subexpressão capturada. Ou seja, ele substitui o nome do computador UNC e da unidade pela letra da unidade.

Comentários

Os métodos de Replace estáticos são equivalentes à construção de um objeto Regex com o padrão de expressão regular especificado e chamar o método de instância Replace.

O parâmetro replacement especifica a cadeia de caracteres que deve substituir cada correspondência em input. replacement pode consistir em qualquer combinação de substituições de texto literal e . Por exemplo, o padrão de substituição a*${test}b insere a cadeia de caracteres "a*" seguida pela subcadeia de caracteres correspondente ao grupo de captura test, se houver, seguido pela cadeia de caracteres "b". O caractere * não é reconhecido como um metacaracter dentro de um padrão de substituição.

Nota

As substituições são os únicos elementos de linguagem de expressão regular reconhecidos em um padrão de substituição. Todos os outros elementos de linguagem de expressão regular, incluindo escapes de caractere , são permitidos apenas em padrões de expressão regular e não são reconhecidos em padrões de substituição.

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

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado. 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. O método estático recomendado para substituir uma correspondência de padrão é Replace(String, String, String, RegexOptions, TimeSpan), o que permite definir o intervalo de tempo limite.

Confira também

substituições em expressões regulares
elementos de linguagem de expressão regular

Aplica-se a

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

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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. Parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência for encontrada.

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

evaluator: MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres original correspondente ou uma cadeia de caracteres de substituição.

options: RegexOptions

Uma combinação bit a bit de valores de enumeração que fornecem opções para correspondência.

matchTimeout: TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve ter tempo limite.

Retornos

String

Exceções

ArgumentException

Ocorreu um erro de análise de expressão regular.

ArgumentNullException

input, patternou evaluator é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores RegexOptions.

-ou-

matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

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 delegado MatchEvaluator para chamar um método chamado WordScramble que embaralha as letras individuais na palavra. Para fazer isso, o método WordScramble cria uma matriz que contém os caracteres na correspondência. Ele também cria uma matriz paralela que preenche com números de ponto flutuante aleatórios. 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. Essa cadeia de caracteres recém-criada é retornada pelo método WordScramble. 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 que não seja de palavra, como um caractere de espaço em branco. A chamada para o método Replace(String, String, MatchEvaluator, RegexOptions) inclui a opção RegexOptions.IgnorePatternWhitespace para 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.

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:

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.
Se a cadeia de caracteres de substituição resultar de algum processamento executado na cadeia de caracteres correspondente.
Se a cadeia de caracteres de substituição resultar do processamento condicional.

O método é equivalente a chamar o método Regex.Matches(String, String, RegexOptions) e passar cada objeto Match na coleção MatchCollection retornada para o delegado evaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Seu método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.

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

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 atingir o tempo limite. A configuraçã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. Para obter mais informações, consulte práticas recomendadas para expressões regulares e backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método gerará uma exceção RegexMatchTimeoutException. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.

Notas aos Chamadores

Recomendamos que você defina o parâmetro matchTimeout como um valor apropriado, como dois segundos. Se você desabilitar o tempo limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular oferecerá um desempenho ligeiramente melhor. No entanto, você deve desabilitar os tempos limite apenas nas seguintes condições:

Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático. Isso exclui o texto que foi inserido dinamicamente pelos usuários.
Quando o padrão de expressão regular tiver sido testado minuciosamente para garantir que ele manipule com eficiência correspondências, não correspondências e correspondências próximas.
Quando o padrão de expressão regular não contém elementos de linguagem conhecidos por causar retrocesso excessivo ao processar uma correspondência próxima.

Confira também

RegexOptions
substituições em expressões regulares
elementos de linguagem de expressão regular
retrocesso em expressões regulares
Práticas recomendadas para expressões regulares no .NET

Aplica-se a

Replace(String, String, MatchEvaluator, RegexOptions)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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. As opções especificadas modificam a operação de correspondência.

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

evaluator: MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres original correspondente ou uma cadeia de caracteres de substituição.

options: RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornecem opções para correspondência.

Retornos

String

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, exceto que uma cadeia de caracteres de substituição assume o lugar de cada cadeia de caracteres correspondente. Se pattern não for correspondido na instância atual, o método retornará a instância atual inalterada.

Exceções

ArgumentException

Ocorreu um erro de análise de expressão regular.

ArgumentNullException

input, patternou evaluator é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores RegexOptions.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

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 se qualquer uma das seguintes condições for verdadeira:

A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.
A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.
A cadeia de caracteres de substituição resulta do processamento condicional.

O método é equivalente a chamar o método Regex.Matches(String, String, RegexOptions) e passar cada objeto Match na coleção MatchCollection retornada para o delegado evaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Seu método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.

Confira também

MatchEvaluator
RegexOptions
substituições em expressões regulares
elementos de linguagem de expressão regular

Aplica-se a

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

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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. Parâmetros adicionais especificam opções que modificam a operação de correspondência e um intervalo de tempo limite se nenhuma correspondência for encontrada.

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

replacement: String

A cadeia de caracteres de substituição.

options: RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornecem opções para correspondência.

matchTimeout: TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve ter tempo limite.

Retornos

String

Exceções

ArgumentException

Ocorreu um erro de análise de expressão regular.

ArgumentNullException

input, patternou replacement é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores RegexOptions.

-ou-

matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

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 por um caminho de arquivo local. 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. 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. Para executar o exemplo com êxito, substitua a cadeia de caracteres literal "MyMachine" pelo nome do computador local.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         string localPath = null;
         try {
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                      RegexOptions.IgnoreCase,
                                      TimeSpan.FromSeconds(0.5));
            Console.WriteLine("Returned string: " + localPath);
         }
         catch (RegexMatchTimeoutException) {
            Console.WriteLine("The replace operation timed out.");
            Console.WriteLine("Returned string: " + localPath);
            if (uncPath.Equals(localPath)) 
               Console.WriteLine("Equal to original path.");
            else
               Console.WriteLine("Original string: " + uncPath);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Dim localPath As String = Nothing
         Try
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                                               RegexOptions.IgnoreCase,
                                                               TimeSpan.FromSeconds(0.5))
            Console.WriteLine("Returned string: " + localPath)         
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("The replace operation timed out.")
            Console.WriteLine("Returned string: " + localPath)
            If uncPath.Equals(localPath) Then 
               Console.WriteLine("Equal to original path.")
            Else
               Console.WriteLine("Original string: " + uncPath)
            End If
         End Try         
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

O padrão de expressão regular é definido pela seguinte expressão:

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

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Padrão	Descrição
`\\\\`	Corresponde a dois caracteres de barra invertida consecutiva (`\`). Como o caractere de barra invertida é interpretado como o caractere de escape, cada barra invertida deve ser escapada com outra barra invertida.
`+ Environment.MachineName +`	Corresponda à cadeia de caracteres retornada pela propriedade Environment.MachineName.
`(?:\.\w+)*`	Corresponde ao caractere de período (`.`) seguido por um ou mais caracteres de palavra. Essa correspondência pode ocorrer zero ou mais vezes. A subexpressão correspondente não é capturada.
`\\`	Corresponder a um caractere de barra invertida (`\`).
`([" + driveNames + "])`	Corresponda à classe de caractere que consiste nas letras de unidade individuais. Essa correspondência é a primeira subexpressão capturada.
`\$`	Corresponda ao caractere de sinal de dólar literal (`$`).

O padrão de substituição $1 substitui toda a correspondência pela primeira subexpressão capturada. Ou seja, ele substitui o nome do computador UNC e da unidade pela letra da unidade.

Comentários

Os métodos de Replace estáticos são equivalentes à construção de um objeto Regex com o padrão de expressão regular especificado e chamar o método de instância Replace.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a corresponder. Para obter mais informações sobre expressões regulares, consulte expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida. 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 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.

Nota

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 atingir o tempo limite. A configuraçã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. Para obter mais informações, consulte práticas recomendadas para expressões regulares e backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método gerará uma exceção RegexMatchTimeoutException. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.

Notas aos Chamadores

Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático. Isso exclui o texto que foi inserido dinamicamente pelos usuários.
Quando o padrão de expressão regular tiver sido testado minuciosamente para garantir que ele manipule com eficiência correspondências, não correspondências e correspondências próximas.
Quando o padrão de expressão regular não contém elementos de linguagem conhecidos por causar retrocesso excessivo ao processar uma correspondência próxima.

Confira também

RegexOptions
substituições em expressões regulares
elementos de linguagem de expressão regular
retrocesso em expressões regulares
Práticas recomendadas para expressões regulares no .NET

Aplica-se a

Replace(String, String, String, RegexOptions)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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. As opções especificadas modificam a operação de correspondência.

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

replacement: String

A cadeia de caracteres de substituição.

options: RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornecem opções para correspondência.

Retornos

String

Exceções

ArgumentException

Ocorreu um erro de análise de expressão regular.

ArgumentNullException

input, patternou replacement é null.

ArgumentOutOfRangeException

options não é uma combinação bit a bit válida de valores RegexOptions.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

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 por um caminho de arquivo local. 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. Todas as comparações de cadeia de caracteres de expressão regular não diferenciam maiúsculas de minúsculas. Para executar o exemplo com êxito, substitua a cadeia de caracteres literal "MyMachine" pelo nome do computador local.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

O padrão de expressão regular é definido pela seguinte expressão:

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

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Padrão	Descrição
`\\\\`	Corresponde a dois caracteres de barra invertida consecutiva (`\`). Como o caractere de barra invertida é interpretado como o caractere de escape, cada barra invertida deve ser escapada com outra barra invertida.
`+ Environment.MachineName +`	Corresponda à cadeia de caracteres retornada pela propriedade Environment.MachineName.
`(?:\.\w+)*`	Corresponde ao caractere de período (`.`) seguido por um ou mais caracteres de palavra. Essa correspondência pode ocorrer zero ou mais vezes. A subexpressão correspondente não é capturada.
`\\`	Corresponder a um caractere de barra invertida (`\`).
`([" + driveNames + "])`	Corresponda à classe de caractere que consiste nas letras de unidade individuais. Essa correspondência é a primeira subexpressão capturada.
`\$`	Corresponda ao caractere de sinal de dólar literal (`$`).

O padrão de substituição $1 substitui toda a correspondência pela primeira subexpressão capturada. Ou seja, ele substitui o nome do computador UNC e da unidade pela letra da unidade.

Comentários

Os métodos de Replace estáticos são equivalentes à construção de um objeto Regex com o padrão de expressão regular especificado e chamar o método de instância Replace.

Nota

Notas aos Chamadores

Confira também

RegexOptions
substituições em expressões regulares
elementos de linguagem de expressão regular

Aplica-se a

Replace(String, MatchEvaluator)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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 a ser pesquisada por uma correspondência.

evaluator: MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres original correspondente ou uma cadeia de caracteres de substituição.

Retornos

String

Exceções

ArgumentNullException

input ou evaluator é null.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

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úscula e exibe a cadeia de caracteres convertida.

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:

A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.
A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.
A cadeia de caracteres de substituição resulta do processamento condicional.

O método é equivalente a chamar o método Regex.Matches(String) e passar cada objeto Match na coleção MatchCollection retornada para o delegado evaluator.

A expressão regular é o padrão definido pelo construtor para o objeto Regex atual.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Seu método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.

Confira também

MatchEvaluator
substituições em expressões regulares
linguagem de expressão regular – referência rápida

Aplica-se a

Replace(String, MatchEvaluator, Int32)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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 retornada por um delegado MatchEvaluator.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String

Parâmetros

input: String

A cadeia de caracteres a ser pesquisada por uma correspondência.

evaluator: MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres original correspondente ou uma cadeia de caracteres de substituição.

count: Int32

O número máximo de vezes que a substituição ocorrerá.

Retornos

String

Exceções

ArgumentNullException

input ou evaluator é null.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

O exemplo a seguir usa uma expressão regular para deliberadamente escrever incorretamente metade das palavras em uma lista. Ele usa a expressão regular \w*(ie|ei)\w* para corresponder a palavras que incluem os caracteres "ie" ou "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. As palavras restantes permanecem inalteradas.

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.

Padrão	Descrição
`\w*`	Corresponder a zero ou mais caracteres de palavra.
`(ie\|ei)`	Corresponde a "ou seja" ou "ei".
`\w*`	Corresponder a zero ou mais caracteres de palavra.

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. Ele corresponde ao segundo "i" ou "e" e atribui a letra ao segundo grupo de captura. Os dois caracteres são revertidos chamando o método Replace(String, String, String) com o padrão de substituição $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:

A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.
A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.
A cadeia de caracteres de substituição resulta do processamento condicional.

O método é equivalente a chamar o método Regex.Matches(String) e passar os primeiros objetos countMatch na coleção MatchCollection retornada para o delegado evaluator.

A expressão regular é o padrão definido pelo construtor para o objeto Regex atual.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Seu método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.

Confira também

MatchEvaluator
substituições em expressões regulares
linguagem de expressão regular – referência rápida

Aplica-se a

Replace(String, String, MatchEvaluator)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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 a ser pesquisada por uma correspondência.

pattern: String

O padrão de expressão regular a ser correspondido.

evaluator: MatchEvaluator

Um método personalizado que examina cada correspondência e retorna a cadeia de caracteres original correspondente ou uma cadeia de caracteres de substituição.

Retornos

String

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, exceto que uma cadeia de caracteres de substituição assume o lugar de cada cadeia de caracteres correspondente. Se pattern não for correspondido na instância atual, o método retornará a instância atual inalterada.

Exceções

ArgumentException

Ocorreu um erro de análise de expressão regular.

ArgumentNullException

input, patternou evaluator é null.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

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:

A cadeia de caracteres de substituição não pode ser prontamente especificada por um padrão de substituição de expressão regular.
A cadeia de caracteres de substituição resulta de algum processamento feito na cadeia de caracteres correspondente.
A cadeia de caracteres de substituição resulta do processamento condicional.

O método é equivalente a chamar o método Regex.Matches(String, String) e passar cada objeto Match na coleção MatchCollection retornada para o delegado evaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Seu método personalizado retorna uma cadeia de caracteres que substitui a entrada correspondente.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado. 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. 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 definir o intervalo de tempo limite.

Confira também

MatchEvaluator
substituições em expressões regulares
elementos de linguagem de expressão regular

Aplica-se a

Replace(String, String, Int32)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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 a ser pesquisada por uma correspondência.

replacement: String

A cadeia de caracteres de substituição.

count: Int32

O número máximo de vezes que a substituição pode ocorrer.

Retornos

String

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, exceto que a cadeia de caracteres de substituição assume o lugar de cada cadeia de caracteres correspondente. Se o padrão de expressão regular não for correspondido na instância atual, o método retornará a instância atual inalterada.

Exceções

ArgumentNullException

input ou replacement é null.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

O exemplo a seguir substitui as cinco primeiras ocorrências de caracteres duplicados por um único caractere. 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. O padrão de substituição $1 substitui toda a correspondência pelo primeiro grupo capturado.

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 input. A expressão regular é o padrão definido pelo construtor para o objeto Regex atual. Se count for negativo, as substituições continuarão até o final da cadeia de caracteres. Se count exceder o número de correspondências, todas as correspondências serão substituídas.

O parâmetro replacement especifica a cadeia de caracteres que deve substituir as primeiras correspondências de count em input. replacement pode consistir em qualquer combinação de substituições de texto literal e . Por exemplo, o padrão de substituição a*${test}b insere a cadeia de caracteres "a*" seguida pela subcadeia de caracteres correspondente ao grupo de captura test, se houver, seguido pela cadeia de caracteres "b". O caractere * não é reconhecido como um metacaracter dentro de um padrão de substituição.

Nota

Confira também

linguagem de expressão regular – referência rápida
substituições em expressões regulares

Aplica-se a

Replace(String, String)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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.

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 a ser pesquisada por uma correspondência.

replacement: String

A cadeia de caracteres de substituição.

Retornos

String

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, exceto que a cadeia de caracteres de substituição assume o lugar de cada cadeia de caracteres correspondente. Se o padrão de expressão regular não for correspondido na instância atual, o método retornará a instância atual inalterada.

Exceções

ArgumentNullException

input ou replacement é null.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

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 um símbolo de moeda à direita de um valor numérico.

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.

Padrão	Descrição
`\p{Sc}`	Corresponder a um símbolo de moeda. `{Sc}` denota qualquer caractere que seja membro da categoria Símbolo Unicode, Moeda.
`\s?`	Corresponder a zero ou a um caractere de espaço em branco.
`(\p{Sc}\s?)?`	Corresponde 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. Este é o primeiro grupo de captura.
`\d+`	Corresponde a um ou mais dígitos decimais.
`\.?`	Corresponder a zero ou uma ocorrência de um período (usado como um caractere separador decimal).
`((?<=\.)\d+)?`	Se um período for o caractere anterior, corresponda a um ou mais dígitos decimais. Esse padrão pode ser correspondido zero ou uma vez.
`(\d+\.?((?<=\.)\d+)?)`	Corresponda ao padrão de um ou mais dígitos decimais seguido por um período opcional e dígitos decimais adicionais. Este é o segundo grupo de captura. A chamada para o método Replace(String, String) substitui toda a correspondência pelo valor desse grupo capturado.
`(?(1)\|\s?\p{Sc})?`	Se o primeiro grupo capturado existir, corresponda a uma cadeia de caracteres vazia. Caso contrário, corresponda a zero ou um caractere de espaço em branco seguido por um símbolo de moeda.

Comentários

A pesquisa de correspondências começa no início da cadeia de caracteres input. A expressão regular é o padrão definido pelo construtor para o objeto Regex atual.

Nota

Confira também

linguagem de expressão regular – referência rápida
substituições em expressões regulares

Aplica-se a

Replace(String, String, Int32, Int32)

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

Origem:: Regex.Replace.cs

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 a ser pesquisada por uma correspondência.

replacement: String

A cadeia de caracteres de substituição.

count: Int32

Número máximo de vezes que a substituição pode ocorrer.

startat: Int32

A posição do caractere na cadeia de caracteres de entrada em que a pesquisa começa.

Retornos

String

Uma nova cadeia de caracteres idêntica à cadeia de caracteres de entrada, exceto que a cadeia de caracteres de substituição assume o lugar de cada cadeia de caracteres correspondente. Se o padrão de expressão regular não for correspondido na instância atual, o método retornará a instância atual inalterada.

Exceções

ArgumentNullException

input ou replacement é null.

ArgumentOutOfRangeException

startat é menor que zero ou maior que o comprimento de input.

RegexMatchTimeoutException

Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.

Exemplos

O exemplo a seguir de espaços duplos, exceto a primeira linha de uma cadeia de caracteres. 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.

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.

Padrão	Descrição
`^`	Corresponda ao início de uma linha. (Observe que o objeto Regex foi instanciado usando a opção RegexOptions.Multiline; caso contrário, essa classe de caractere corresponderia apenas ao início da cadeia de caracteres de entrada.)
`.*`	Corresponda a qualquer caractere zero ou mais vezes.
`$`	Corresponde ao final de uma linha. (Observe que o objeto Regex foi instanciado usando a opção RegexOptions.Multiline; caso contrário, essa classe de caractere corresponderia apenas ao início da cadeia de caracteres de entrada.)

A cadeia de caracteres de substituição (vbCrLf + "$&" no Visual Basic, "\n$&" em C#) adiciona uma nova linha antes da cadeia de caracteres correspondente. Observe que \n no exemplo de C# é interpretado como o caractere de nova linha pelo compilador C#; ele não representa uma fuga de caractere de expressão regular.

Comentários

A pesquisa de correspondências começa na cadeia de caracteres input na posição especificada pelo parâmetro startat. A expressão regular é o padrão definido pelo construtor para o objeto Regex atual. Se count for negativo, as substituições continuarão até o final da cadeia de caracteres. Se count exceder o número de correspondências, todas as correspondências serão substituídas.

Para obter mais detalhes sobre startat, consulte a seção Comentários do Match(String, Int32).

Nota

Confira também

substituições em expressões regulares
linguagem de expressão regular – referência rápida

Aplica-se a

Partilhar via

Regex.Replace Método

Definição

Sobrecargas

Replace(String, MatchEvaluator, Int32, Int32)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Replace(String, String, String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

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

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Replace(String, String, MatchEvaluator, RegexOptions)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

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

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Replace(String, String, String, RegexOptions)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a

Replace(String, MatchEvaluator)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Replace(String, MatchEvaluator, Int32)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Replace(String, String, MatchEvaluator)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Notas aos Chamadores

Confira também

Aplica-se a