Regex.Replace Método

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte usa uma expressão regular para extrair as palavras individuais de uma cadeia de caracteres, e depois usa um MatchEvaluator delegado para chamar um método chamado WordScramble que embaralha as letras individuais da palavra. Para isso, o WordScramble método cria um array que contém os caracteres da partida. Também cria um array paralelo que preenche com números aleatórios de ponto flutuante. Os arrays são ordenados chamando o Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método, e o array ordenado é fornecido como argumento a um String construtor de classes. Esta cadeia recém-criada é então devolvida pelo WordScramble método. O padrão \w+ de expressão regular corresponde a um ou mais caracteres de palavra; o motor de expressões regulares continuará a adicionar caracteres à correspondência até encontrar um carácter que não seja palavra, como um carácter de espaço em branco. A chamada ao Replace(String, String, MatchEvaluator, RegexOptions) método inclui a RegexOptions.IgnorePatternWhitespace opção de que o comentário no padrão \w+ # Matches all the characters in a word. de expressão regular seja ignorado pelo motor de expressões regulares.

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

Observações

O Regex.Replace(String, String, MatchEvaluator, RegexOptions) método é útil para substituir uma correspondência de expressões regulares se alguma das seguintes condições for verdadeira:

• Se a cadeia de substituição não puder ser facilmente especificada por um padrão de substituição de expressão regular.

• Se a cadeia de substituição resultar de algum processamento realizado na cadeia correspondente.

• Se a cadeia de substituição resultar de processamento condicional.

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

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia correspondente. Para mais informações sobre expressões regulares, consulte .NET Expressões Regulares e Linguagem de Expressões Regulares - Referência Rápida.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

O teu método personalizado devolve uma string que substitui a entrada correspondente.

Se especificar RightToLeft para o options parâmetro, a pesquisa por correspondências começa no final da cadeia de entrada e move-se para a esquerda; caso contrário, a pesquisa começa no início da cadeia de entrada e move-se para a direita.

O matchTimeout parâmetro especifica quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de expirar. Definir um intervalo de time-out impede que expressões regulares que dependem de retrocessos excessivos pareçam "parar de responder quando processam entradas que contêm correspondências próximas. Para mais informações, consulte Melhores Práticas para Expressões Regulares e Retrocesso. Se não for encontrada correspondência nesse intervalo de tempo, o método lança uma RegexMatchTimeoutException exceção. matchTimeout sobrepõe-se a qualquer valor de time-out padrão definido para o domínio de aplicação onde o método é executado.

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

Notas para Chamadores

Recomendamos que defina o matchTimeout parâmetro para um valor apropriado, como dois segundos. Se desativar os tempos de espera especificando InfiniteMatchTimeout, o motor de expressão regular oferece um desempenho ligeiramente melhor. No entanto, deve desativar os tempos de espera apenas nas seguintes condições:

• Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e de confiança ou consiste em texto estático. Isto exclui texto que tenha sido introduzido dinamicamente pelos utilizadores.

• Quando o padrão de expressão regular foi cuidadosamente testado para garantir que lida eficientemente com correspondências, não correspondências e próximas correspondências.

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

Ver também

• RegexOptions
• Substituições em expressões regulares
• Elementos da Linguagem de Expressões Regulares
• Retrocesso em expressões regulares
• Melhores práticas para expressões regulares em .NET

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte utiliza o Replace(String, String, String, RegexOptions, TimeSpan) método para substituir os nomes da máquina local e dos discos num caminho UNC por um caminho local de ficheiro. A expressão regular utiliza a Environment.MachineName propriedade para incluir o nome do computador local e o Environment.GetLogicalDrives método para incluir os nomes dos discos lógicos. Todas as comparações de cadeias de expressões regulares são indiferentes a maiúsculas e minúsculas, e qualquer operação de substituição única expira se não for possível encontrar uma correspondência em 0,5 segundos. Para executar o exemplo com sucesso, deve substituir a string literal "MyMachine" pelo nome da sua máquina 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.

Pattern	Description
\\\\	Corresponde a dois caracteres consecutivos com barra inversa (\). Como o carácter de barras inversas é interpretado como o carácter de fuga, cada barra invertida deve ser escapada com outra barra.
+ Environment.MachineName +	Corresponder à cadeia que é devolvida pela Environment.MachineName propriedade.
(?:\.\w+)*	Corresponda ao carácter ponto (.) seguido de um ou mais caracteres de palavra. Este jogo pode ocorrer zero ou mais vezes. A subexpressão correspondente não é captada.
\\	Combina com uma personagem com barra inversa (\).
([" + driveNames + "])	Corresponda à classe de carácter que consiste nas letras da unidade individuais. Esta correspondência é a primeira subexpressão capturada.
\$	Corresponde ao carácter literal do cifrão ($).

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

Observações

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

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia correspondente. Para mais informações sobre expressões regulares, consulte .NET Expressões Regulares e Linguagem de Expressões Regulares - Referência Rápida. Se especificar RightToLeft para o options parâmetro, a pesquisa por correspondências começa no final da cadeia de entrada e move-se para a esquerda; caso contrário, a pesquisa começa no início da cadeia de entrada e move-se para a direita.

O replacement parâmetro especifica a cadeia que substituirá cada correspondência em input. replacement pode consistir em qualquer combinação de texto literal e substituições. Por exemplo, o padrão a*${test}b de substituição insere a cadeia "a*" seguida da subcadeia que é correspondida pelo test grupo capturador, se existir, seguida da cadeia "b". O caractere * não é reconhecido como metapersonagem dentro de um padrão de substituição.

O matchTimeout parâmetro especifica quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de expirar. Definir um intervalo de tempo impede que expressões regulares que dependem de retrocessos excessivos pareçam deixar de responder quando processam entradas que contenham correspondências próximas. Para mais informações, consulte Melhores Práticas para Expressões Regulares e Retrocesso. Se não for encontrada correspondência nesse intervalo de tempo, o método lança uma RegexMatchTimeoutException exceção. matchTimeout sobrepõe-se a qualquer valor de time-out padrão definido para o domínio de aplicação onde o método é executado.

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

Notas para Chamadores

Recomendamos que defina o matchTimeout parâmetro para um valor apropriado, como dois segundos. Se desativar os tempos de espera especificando InfiniteMatchTimeout, o motor de expressão regular oferece um desempenho ligeiramente melhor. No entanto, deve desativar os tempos de espera apenas nas seguintes condições:

• Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e de confiança ou consiste em texto estático. Isto exclui texto que tenha sido introduzido dinamicamente pelos utilizadores.

• Quando o padrão de expressão regular foi cuidadosamente testado para garantir que lida eficientemente com correspondências, não correspondências e próximas correspondências.

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

Ver também

• RegexOptions
• Substituições em expressões regulares
• Elementos da Linguagem de Expressões Regulares
• Retrocesso em expressões regulares
• Melhores práticas para expressões regulares em .NET

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

Devoluções

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

Exceções

Observações

O Regex.Replace(String, MatchEvaluator, Int32, Int32) método é útil para substituir uma correspondência de expressões regulares se alguma das seguintes condições for verdadeira:

• A corda de substituição não pode ser facilmente especificada por um padrão de substituição de expressão regular.
• A cadeia de substituição resulta de algum processamento realizado na cadeia emparelhada.
• A cadeia de substituição resulta do processamento condicional.

O método é equivalente a chamar o Regex.Matches(String, Int32) método e passar os primeirosMatchcountobjetos da coleção devolvida MatchCollection ao evaluator delegado.

Para mais detalhes sobre startat, veja a secção Observações de Match(String, Int32).

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

O teu método personalizado devolve uma string que substitui a entrada correspondente.

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

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

Ver também

• MatchEvaluator
• Substituições em expressões regulares
• Linguagem de Expressão Regular - Referência Rápida

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte usa uma expressão regular para extrair as palavras individuais de uma cadeia de caracteres, e depois usa um MatchEvaluator delegado para chamar um método chamado WordScramble que embaralha as letras individuais da palavra. Para isso, o WordScramble método cria um array que contém os caracteres da partida. Também cria um array paralelo que preenche com números aleatórios de ponto flutuante. Os arrays são ordenados chamando o Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método, e o array ordenado é fornecido como argumento a um String construtor de classes. Esta cadeia recém-criada é então devolvida pelo WordScramble método. O padrão \w+ de expressão regular corresponde a um ou mais caracteres de palavra; o motor de expressões regulares continuará a adicionar caracteres à correspondência até encontrar um carácter que não seja palavra, como um carácter de espaço em branco. A chamada ao Replace(String, String, MatchEvaluator, RegexOptions) método inclui a RegexOptions.IgnorePatternWhitespace opção de que o comentário no padrão \w+ # Matches all the characters in a word. de expressão regular seja ignorado pelo motor de expressões regulares.

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

Observações

O Regex.Replace(String, String, MatchEvaluator, RegexOptions) método é útil para substituir uma correspondência de expressão regular em se alguma das seguintes condições for verdadeira:

• A corda de substituição não pode ser facilmente especificada por um padrão de substituição de expressão regular.

• A cadeia de substituição resulta de algum processamento realizado na cadeia emparelhada.

• A cadeia de substituição resulta do processamento condicional.

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

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia correspondente. Para mais informações sobre expressões regulares, consulte .NET Expressões Regulares e Linguagem de Expressões Regulares - Referência Rápida.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

O teu método personalizado devolve uma string que substitui a entrada correspondente.

Se especificar RightToLeft para o options parâmetro, a pesquisa por correspondências começa no final da cadeia de entrada e move-se para a esquerda; caso contrário, a pesquisa começa no início da cadeia de entrada e move-se para a direita.

A RegexMatchTimeoutException exceção é lançada se o tempo de execução da operação de substituição exceder o intervalo de tempo especificado para o domínio de aplicação em que o método é chamado. Se não for definido time-out nas propriedades do domínio de aplicação, ou se o valor de time-out for Regex.InfiniteMatchTimeout, nenhuma exceção é lançada.

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

Ver também

• MatchEvaluator
• RegexOptions
• Substituições em expressões regulares
• Elementos da Linguagem de Expressões Regulares

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte faz espaços duplos em todas as linhas exceto a primeira linha de uma corda. Define um padrão de expressão regular, ^.*$, que corresponde a uma linha de texto, chama o Match(String) método para corresponder à primeira linha da cadeia e usa as Match.Index propriedades 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.

Pattern	Description
^	Corresponde ao início de uma linha. (Note que o Regex objeto foi instanciado usando a RegexOptions.Multiline opção; caso contrário, esta classe de carácter apenas corresponderia ao início da cadeia de entrada.)
.*	Corresponder a qualquer caractere zero ou mais vezes.
$	Corresponde ao fim de uma linha. (Note que o Regex objeto foi instanciado usando a RegexOptions.Multiline opção; caso contrário, esta classe de carácter apenas corresponderia ao início da cadeia de entrada.)

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

Observações

A procura de correspondências começa na input sequência na posição especificada pelo startat parâmetro. A expressão regular é o padrão definido pelo construtor para o objeto atual Regex . Se count for negativo, as substituições continuam até ao fim da corda. Se count exceder o número de fósforos, todos os fósforos são substituídos.

Para mais detalhes sobre startat, veja a secção Observações de Match(String, Int32).

O replacement parâmetro especifica a cadeia que substituirá cada correspondência em input. replacement pode consistir em qualquer combinação de texto literal e substituições. Por exemplo, o padrão a*${test}b de substituição insere a cadeia "a*" seguida da subcadeia que é correspondida pelo test grupo capturador, se existir, seguida da cadeia "b". O caractere * não é reconhecido como metapersonagem dentro de um padrão de substituição.

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

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

Ver também

• Substituições em expressões regulares
• Linguagem de Expressão Regular - Referência Rápida

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte utiliza o Replace(String, String, String, RegexOptions) método para substituir os nomes da máquina local e dos discos num caminho UNC por um caminho local de ficheiro. A expressão regular utiliza a Environment.MachineName propriedade de incluir o nome do computador local e o Environment.GetLogicalDrives método de incluir os nomes das unidades lógicas. Todas as comparações de cadeias de expressões regulares são indiferentes a maiúsculas minúsculas. Para executar o exemplo com sucesso, deve substituir a string literal "MyMachine" pelo nome da sua máquina 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.

Pattern	Description
\\\\	Corresponde a dois caracteres consecutivos com barra inversa (\). Como o carácter de barras inversas é interpretado como o carácter de fuga, cada barra invertida deve ser escapada com outra barra.
+ Environment.MachineName +	Corresponder à cadeia que é devolvida pela Environment.MachineName propriedade.
(?:\.\w+)*	Corresponda ao carácter ponto (.) seguido de um ou mais caracteres de palavra. Este jogo pode ocorrer zero ou mais vezes. A subexpressão correspondente não é captada.
\\	Combina com uma personagem com barra inversa (\).
([" + driveNames + "])	Corresponda à classe de carácter que consiste nas letras da unidade individuais. Esta correspondência é a primeira subexpressão capturada.
\$	Corresponde ao carácter literal do cifrão ($).

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

Observações

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

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia correspondente. Para mais informações sobre expressões regulares, consulte .NET Expressões Regulares e Linguagem de Expressões Regulares - Referência Rápida. Se especificar RightToLeft para o options parâmetro, a pesquisa por correspondências começa no final da cadeia de entrada e move-se para a esquerda; caso contrário, a pesquisa começa no início da cadeia de entrada e move-se para a direita.

O replacement parâmetro especifica a cadeia que substituirá cada correspondência em input. replacement pode consistir em qualquer combinação de texto literal e substituições. Por exemplo, o padrão a*${test}b de substituição insere a cadeia "a*" seguida da subcadeia que é correspondida pelo test grupo capturador, se existir, seguida da cadeia "b". O caractere * não é reconhecido como metapersonagem dentro de um padrão de substituição.

A RegexMatchTimeoutException exceção é lançada se o tempo de execução da operação de substituição exceder o intervalo de tempo especificado para o domínio de aplicação em que o método é chamado. Se não for definido time-out nas propriedades do domínio de aplicação, ou se o valor de time-out for Regex.InfiniteMatchTimeout, nenhuma exceção é lançada.

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

Notas para Chamadores

Este método expira após um intervalo igual ao valor de tempo limite padrão do domínio de aplicação em que é chamado. Se não tiver sido definido um valor de time-out para o domínio de aplicação, utiliza-se o valor InfiniteMatchTimeout, que impede que o método expire. O método estático recomendado para substituir uma correspondência de padrão é Replace(String, String, String, RegexOptions, TimeSpan), que permite definir o intervalo de time-out.

Ver também

• RegexOptions
• Substituições em expressões regulares
• Elementos da Linguagem de Expressões Regulares

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte usa uma expressão regular para extrair as palavras individuais de uma cadeia de caracteres, e depois usa um MatchEvaluator delegado para chamar um método chamado WordScramble que embaralha as letras individuais da palavra. Para isso, o WordScramble método cria um array que contém os caracteres da partida. Também cria um array paralelo que preenche com números aleatórios de ponto flutuante. Os arrays são ordenados chamando o Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método, e o array ordenado é fornecido como argumento a um String construtor de classes. Esta cadeia recém-criada é então devolvida pelo WordScramble método. O padrão \w+ de expressão regular corresponde a um ou mais caracteres de palavra; o motor de expressões regulares continuará a adicionar caracteres à correspondência até encontrar um carácter que não seja palavra, como um carácter de espaço em branco.

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

Observações

O Regex.Replace(String, String, MatchEvaluator) método é útil para substituir uma correspondência de expressões regulares se alguma das seguintes condições for verdadeira:

• A corda de substituição não pode ser facilmente especificada por um padrão de substituição de expressão regular.

• A cadeia de substituição resulta de algum processamento realizado na cadeia emparelhada.

• A cadeia de substituição resulta do processamento condicional.

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

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia correspondente. Para mais informações sobre expressões regulares, consulte .NET Expressões Regulares e Linguagem de Expressões Regulares - Referência Rápida.

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

O teu método personalizado devolve uma string que substitui a entrada correspondente.

A RegexMatchTimeoutException exceção é lançada se o tempo de execução da operação de substituição exceder o intervalo de tempo especificado para o domínio de aplicação em que o método é chamado. Se não for definido time-out nas propriedades do domínio de aplicação, ou se o valor de time-out for Regex.InfiniteMatchTimeout, nenhuma exceção é lançada.

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

Notas para Chamadores

Este método expira após um intervalo igual ao valor de tempo limite padrão do domínio de aplicação em que é chamado. Se não tiver sido definido um valor de time-out para o domínio de aplicação, utiliza-se o valor InfiniteMatchTimeout, que impede que o método expire. O método estático recomendado para avaliar e substituir uma correspondência de padrão é Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), que permite definir o intervalo de time-out.

Ver também

• MatchEvaluator
• Substituições em expressões regulares
• Elementos da Linguagem de Expressões Regulares

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

Devoluções

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

Exceções

Exemplos

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

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 seguinte utiliza o Replace(String, String, String) método para substituir os nomes da máquina local e dos discos num caminho UNC por um caminho local de ficheiro. A expressão regular utiliza a Environment.MachineName propriedade de incluir o nome do computador local e o Environment.GetLogicalDrives método de incluir os nomes das unidades lógicas. Para executar o exemplo com sucesso, deve substituir a string literal "MyMachine" pelo nome da sua máquina 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.

Pattern	Description
\\\\	Corresponde a dois caracteres consecutivos com barra inversa (\). Como o carácter de barras inversas é interpretado como o carácter de fuga, cada barra invertida deve ser escapada com outra barra.
(?i:" + Environment.MachineName + ")	Realiza uma correspondência insensível a maiúsculas e minúsculas da cadeia que é devolvida pela Environment.MachineName propriedade.
(?:\.\w+)*	Corresponda ao carácter ponto (.) seguido de um ou mais caracteres de palavra. Este jogo pode ocorrer zero ou mais vezes. A subexpressão correspondente não é captada.
\\	Combina com uma personagem com barra inversa (\).
((?i:[" + driveNames + "]))	Realize uma correspondência insensível a maiúsculas e maiúsculas da classe de carácter que consiste nas letras individuais da unidade. Esta correspondência é a primeira subexpressão capturada.
\$	Corresponde ao carácter literal do cifrão ($).

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

Observações

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

O pattern parâmetro consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia correspondente. Para mais informações sobre expressões regulares, consulte .NET Expressões Regulares e Linguagem de Expressões Regulares - Referência Rápida. A procura por correspondências começa no início da input sequência.

O replacement parâmetro especifica a cadeia que substituirá cada correspondência em input. replacement pode consistir em qualquer combinação de texto literal e substituições. Por exemplo, o padrão a*${test}b de substituição insere a cadeia "a*" seguida da subcadeia que é correspondida pelo test grupo capturador, se existir, seguida da cadeia "b". O caractere * não é reconhecido como metapersonagem dentro de um padrão de substituição.

A RegexMatchTimeoutException exceção é lançada se o tempo de execução da operação de substituição exceder o intervalo de tempo especificado para o domínio de aplicação em que o método é chamado. Se não for definido time-out nas propriedades do domínio de aplicação, ou se o valor de time-out for Regex.InfiniteMatchTimeout, nenhuma exceção é lançada.

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

Notas para Chamadores

Este método expira após um intervalo igual ao valor de tempo limite padrão do domínio de aplicação em que é chamado. Se não tiver sido definido um valor de time-out para o domínio de aplicação, utiliza-se o valor InfiniteMatchTimeout, que impede que o método expire. O método estático recomendado para substituir uma correspondência de padrão é Replace(String, String, String, RegexOptions, TimeSpan), que permite definir o intervalo de time-out.

Ver também

• Substituições em expressões regulares
• Elementos da Linguagem de Expressões Regulares

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte substitui as primeiras cinco ocorrências de caracteres duplicados por um único carácter. O padrão (\w)\1 de expressão regular corresponde a ocorrências consecutivas de um único carácter e atribui a primeira ocorrência ao primeiro grupo que capturou. O padrão $1 de substituição troca todo o jogo 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'

Observações

A procura por correspondências começa no início da input sequência. A expressão regular é o padrão definido pelo construtor para o objeto atual Regex . Se count for negativo, as substituições continuam até ao fim da corda. Se count exceder o número de fósforos, todos os fósforos são substituídos.

O replacement parâmetro especifica a cadeia que substitui a primeira count corresponde a .input replacement pode consistir em qualquer combinação de texto literal e substituições. Por exemplo, o padrão a*${test}b de substituição insere a cadeia "a*" seguida da subcadeia que é correspondida pelo test grupo capturador, se existir, seguida da cadeia "b". O caractere * não é reconhecido como metapersonagem dentro de um padrão de substituição.

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

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

Ver também

• Linguagem de Expressão Regular - Referência Rápida
• Substituições em expressões regulares

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

Devoluções

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

Exceções

Exemplos

O exemplo de código seguinte apresenta uma cadeia original, corresponde a cada palavra na cadeia original, converte o primeiro carácter de cada correspondência em maiúsculas e depois mostra a cadeia 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]

Observações

O Regex.Replace(String, MatchEvaluator) método é útil para substituir uma correspondência de expressões regulares se alguma das seguintes condições for verdadeira:

• A corda de substituição não pode ser facilmente especificada por um padrão de substituição de expressão regular.

• A cadeia de substituição resulta de algum processamento realizado na cadeia emparelhada.

• A cadeia de substituição resulta do processamento condicional.

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

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

O teu método personalizado devolve uma string que substitui a entrada correspondente.

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

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

Ver também

• MatchEvaluator
• Substituições em expressões regulares
• Linguagem de Expressão Regular - Referência Rápida

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

Devoluções

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

Exceções

Exemplos

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

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 seguinte 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 inicial ou de final 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 como mostrado na tabela a seguir.

Pattern	Description
\p{Sc}	Corresponde a um símbolo de moeda. {Sc} denota qualquer carácter 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?)?	Corresponda zero ou uma ocorrência da combinação de um símbolo de moeda seguida de zero ou de um carácter de espaço em branco. Este é o primeiro grupo de captura.
\d+	Corresponder a um ou mais dígitos decimais.
\.?	Corresponder a zero ou uma ocorrência de um período (usada como carácter separador decimal).
((?<=\.)\d+)?	Se um ponto for o carácter anterior, corresponda a um ou mais dígitos decimais. Este padrão pode ser igualado a zero ou uma vez.
(\d+\.?((?<=\.)\d+)?)	Corresponder ao padrão de um ou mais dígitos decimais seguidos de um ponto opcional e dígitos decimais adicionais. Este é o segundo grupo de captura. A chamada ao Replace(String, String) método substitui toda a correspondência pelo valor deste grupo capturado.
(?(1)|\s?\p{Sc})?	Se existir o primeiro grupo capturado, corresponde a uma cadeia vazia. Caso contrário, corresponde a zero ou a um carácter de espaço em branco seguido de um símbolo de moeda.

Observações

A procura por correspondências começa no início da input sequência. A expressão regular é o padrão definido pelo construtor para o objeto atual Regex .

O replacement parâmetro especifica a cadeia que substituirá cada correspondência em input. replacement pode consistir em qualquer combinação de texto literal e substituições. Por exemplo, o padrão a*${test}b de substituição insere a cadeia "a*" seguida da subcadeia que é correspondida pelo test grupo capturador, se existir, seguida da cadeia "b". O caractere * não é reconhecido como metapersonagem dentro de um padrão de substituição.

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

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

Ver também

• Linguagem de Expressão Regular - Referência Rápida
• Substituições em expressões regulares

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

Devoluções

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

Exceções

Exemplos

O exemplo seguinte usa uma expressão regular para escrever deliberadamente mal metade das palavras de uma lista. Utiliza a expressão \w*(ie|ei)\w* regular para corresponder a palavras que incluem os caracteres "ie" ou "ei". Passa a primeira metade das palavras correspondentes ao ReverseLetter método, que, por sua vez, usa o Replace(String, String, String, RegexOptions) método para inverter o "i" e o "e" na sequência correspondente. As palavras restantes mantêm-se 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 \w*(ie|ei)\w* regular é definida conforme mostrado na tabela a seguir.

Pattern	Description
\w*	Corresponder a zero ou mais caracteres de palavras.
(ie|ei)	Corresponde a "ie" ou "ei".
\w*	Corresponder a zero ou mais caracteres de palavras.

O padrão ([ie])([ie]) de expressão regular do ReverseLetter método corresponde ao primeiro "i" ou "e" no ditongo "ie" ou "ei" e atribui a letra ao primeiro grupo de captura. Corresponde ao segundo "i" ou "e" e atribui a letra ao segundo grupo que captura. Os dois caracteres são então invertidos chamando o Replace(String, String, String) método com o padrão $2$1de substituição .

Observações

O Regex.Replace(String, MatchEvaluator, Int32) método é útil para substituir uma correspondência de expressões regulares se alguma das seguintes condições for verdadeira:

• A corda de substituição não pode ser facilmente especificada por um padrão de substituição de expressão regular.

• A cadeia de substituição resulta de algum processamento realizado na cadeia emparelhada.

• A cadeia de substituição resulta do processamento condicional.

O método é equivalente a chamar o Regex.Matches(String) método e passar os primeirosMatchcountobjetos da coleção devolvida MatchCollection ao evaluator delegado.

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

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

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

O teu método personalizado devolve uma string que substitui a entrada correspondente.

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

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

Ver também

• MatchEvaluator
• Substituições em expressões regulares
• Linguagem de Expressão Regular - Referência Rápida