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

Definición

En una cadena de entrada especificada, reemplaza las cadenas que coinciden con un modelo de expresión regular por una cadena de reemplazo especificada. In a specified input string, replaces strings that match a regular expression pattern with a specified replacement string.

Sobrecargas

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

En una cadena de entrada especificada, reemplaza todas las subcadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia. Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia. Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

En una subcadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un modelo de expresión regular por una cadena devuelta por un delegado MatchEvaluator. In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Las opciones especificadas modifican la operación de coincidencia. Specified options modify the matching operation.

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

En una subcadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada. In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Las opciones especificadas modifican la operación de coincidencia. Specified options modify the matching operation.

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

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

En una cadena de entrada especificada, reemplaza un número máximo indicado de cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada. In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada. In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

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

En una cadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un modelo de expresión regular por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

En una cadena de entrada especificada, reemplaza todas las subcadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia. Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions, matchTimeout As TimeSpan) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias. The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo. A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinación bit a bit de los valores de la enumeración que proporcionan opciones de coincidencia. A bitwise combination of enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera. A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

Se produjo un error de análisis de expresión regular. A regular expression parsing error occurred.

input, pattern o evaluator es null. input, pattern, or evaluator is null.

options no es una combinación bit a bit válida de valores RegexOptions. options is not a valid bitwise combination of RegexOptions values. O bien -or- matchTimeout es negativo, cero o mayor que 24 días aproximadamente. matchTimeout is negative, zero, or greater than approximately 24 days.

Se agotó un tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

El ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, usa un MatchEvaluator delegado para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. Para ello, el WordScramble método crea una matriz que contiene los caracteres de la coincidencia.To do this, the WordScramble method creates an array that contains the characters in the match. También se crea una matriz paralela que se rellena con números de punto flotante aleatorios.It also creates a parallel array that it populates with random floating-point numbers. Las matrices se ordenan mediante una llamada a la Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método y la matriz ordenada se proporciona como argumento a un String constructor de clase.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. A continuación, se devuelve esta cadena recién creada por el WordScramble método.This newly created string is then returned by the WordScramble method. El patrón de expresión regular \w+ coincide con uno o más caracteres alfabéticos; el motor de expresiones regulares continuará agregando caracteres a la coincidencia hasta que encuentra un carácter que no sea de palabra, como un carácter de espacio en blanco.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character. La llamada a la Replace(String, String, MatchEvaluator, RegexOptions) método incluye el RegexOptions.IgnorePatternWhitespace opción para que el comentario en el patrón de expresión regular \w+ # Matches all the characters in a word. omitido por el motor de expresiones regulares.The call to the Replace(String, String, MatchEvaluator, RegexOptions) method includes the RegexOptions.IgnorePatternWhitespace option so that the comment in the regular expression pattern \w+ # Matches all the characters in a word. is ignored by the regular expression engine.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      try {
         Console.WriteLine("Scrambled words:");
         Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)));      
      }
      catch (RegexMatchTimeoutException) {
         Console.WriteLine("Word Scramble operation timed out.");
         Console.WriteLine("Returned words:");
      }
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Try
         Console.WriteLine("Scrambled words:")
         Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)))      
      Catch e As RegexMatchTimeoutException
         Console.WriteLine("Word Scramble operation timed out.")
         Console.WriteLine("Returned words:")
      End Try   
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Comentarios

El Regex.Replace(String, String, MatchEvaluator, RegexOptions) método es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match if any of the following conditions is true:

  • Si la cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresión regular.If the replacement string cannot readily be specified by a regular expression replacement pattern.

  • Si la cadena de reemplazo que da como resultado de realiza algún procesamiento en la cadena coincidente.If the replacement string results from some processing performed on the matched string.

  • Si da como resultado de la cadena de reemplazo de un procesamiento condicional.If the replacement string results from conditional processing.

El método es equivalente a llamar a la Regex.Matches(String, String, RegexOptions) método y pasar cada Match objeto en el valor devuelto MatchCollection colección a la evaluator delegar.The method is equivalent to calling the Regex.Matches(String, String, RegexOptions) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

El pattern parámetro consta de los elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET Framework y lenguaje de expresiones regulares - referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

El evaluator parámetro es el delegado de un método personalizado que define y que examina cada coincidencia.The evaluator parameter is the delegate for a custom method that you define and that examines each match. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegar.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.Your custom method returns a string that replaces the matched input.

Si especifica RightToLeft para el options parámetro, la búsqueda de coincidencias empieza al final de la cadena de entrada y se mueve a la izquierda; en caso contrario, la búsqueda comienza al principio de la cadena de entrada y se desplaza hacia la derecha.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

El matchTimeout parámetro especifica cómo larga una coincidencia de método debe intentar buscar una coincidencia antes de expirar. Establecer un intervalo de tiempo de espera evita que las expresiones regulares que se basan en un retroceso excesivo que aparezca en "dejar de responder al procesar la entrada que contenga cerca de coincidencias.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to "stop responding when they process input that contains near matches. Para obtener más información, consulte procedimientos recomendados con expresiones regulares y retroceso.For more information, see Best Practices for Regular Expressions and Backtracking. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una RegexMatchTimeoutException excepción.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Notas a los autores de las llamadas

Se recomienda que establezca el matchTimeout parámetro a un valor apropiado, como dos segundos. We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si deshabilita los tiempos de espera mediante la especificación de InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Sin embargo, debe deshabilitar los tiempos de espera solo en las siguientes condiciones: However, you should disable time-outs only under the following conditions: -Cuando la entrada procesada por una expresión regular se deriva de una fuente conocida y de confianza o consta de texto estático. - When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Excluye el texto que ha sido dinámicamente por usuarios. This excludes text that has been dynamically input by users. -Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla con gran eficacia coincide, la ausencia de coincidencias y próximo coincide con. - When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches. -Cuando el patrón de expresión regular contiene ningún elemento de lenguaje que causan un retroceso excesivo al procesar a una coincidencia casi. - When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Consultar también

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Los parámetros adicionales especifican las opciones que modifican la operación de coincidencia y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia. Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions, matchTimeout As TimeSpan) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias. The regular expression pattern to match.

replacement
String String String String

La cadena de reemplazo. The replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia. A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan TimeSpan TimeSpan TimeSpan

Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera. A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

Se produjo un error de análisis de expresión regular. A regular expression parsing error occurred.

input, pattern o replacement es null. input, pattern, or replacement is null.

options no es una combinación bit a bit válida de valores RegexOptions. options is not a valid bitwise combination of RegexOptions values. O bien -or- matchTimeout es negativo, cero o mayor que 24 días aproximadamente. matchTimeout is negative, zero, or greater than approximately 24 days.

Se agotó un tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo siguiente se usa el Replace(String, String, String, RegexOptions, TimeSpan) método para reemplazar los nombres de equipo y la unidad locales en una ruta de acceso UNC con una ruta de acceso de archivo local.The following example uses the Replace(String, String, String, RegexOptions, TimeSpan) method to replace the local machine and drive names in a UNC path with a local file path. La expresión regular usa el Environment.MachineName propiedad para incluir el nombre del equipo local y el Environment.GetLogicalDrives método para incluir los nombres de las unidades lógicas.The regular expression uses the Environment.MachineName property to include the name of the local computer and the Environment.GetLogicalDrives method to include the names of the logical drives. Todas las comparaciones de cadenas de expresiones regulares distinguen mayúsculas de minúsculas, y cualquier operación de reemplazo único tiempo de espera si no se encuentra una coincidencia en 0,5 segundos.All regular expression string comparisons are case-insensitive, and any single replacement operation times out if a match cannot be found in 0.5 second. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" con el nombre del equipo local.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

using System;
using System.Text.RegularExpressions;

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

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

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

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

El patrón de expresión regular se define mediante la siguiente expresión:The regular expression pattern is defined by the following expression:

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

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.The following table shows how the regular expression pattern is interpreted.

ModeloPattern DescripciónDescription
\\\\ Barra diagonal inversa de coincidencia dos consecutivo (\) caracteres.Match two consecutive backslash (\) characters. Dado que el carácter de barra diagonal inversa se interpreta como carácter de escape, cada barra diagonal inversa debe ser de escape con otra barra diagonal inversa.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Coincide con la cadena devuelta por la Environment.MachineName propiedad.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Coincide con el período (.) carácter seguido de uno o más caracteres alfabéticos.Match the period (.) character followed by one or more word characters. Esta coincidencia puede aparecer cero o más veces.This match can occur zero or more times. No se captura la subexpresión coincidente.The matched subexpression is not captured.
\\ Coincide con una barra diagonal inversa (\) caracteres.Match a backslash (\) character.
([" + driveNames + "]) Coincide con la clase de caracteres formado por las letras de unidad individuales.Match the character class that consists of the individual drive letters. Esta coincidencia es la primera subexpresión capturada.This match is the first captured subexpression.
\$ Coincide con el signo de dólar literal ($) caracteres.Match the literal dollar sign ($) character.

El patrón de reemplazo $1 reemplaza toda la coincidencia con la primera subexpresión capturada.The replacement pattern $1 replaces the entire match with the first captured subexpression. Es decir, reemplaza el nombre de equipo y la unidad UNC con la letra de unidad.That is, it replaces the UNC machine and drive name with the drive letter.

Comentarios

Estático Replace métodos son equivalentes a construir un Regex con el patrón de expresión regular especificada de objetos y llamar al método de instancia Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

El pattern parámetro consta de los elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET Framework y lenguaje de expresiones regulares - referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Si especifica RightToLeft para el options parámetro, la búsqueda de coincidencias empieza al final de la cadena de entrada y se mueve a la izquierda; en caso contrario, la búsqueda comienza al principio de la cadena de entrada y se desplaza hacia la derecha.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

El replacement parámetro especifica la cadena que va a reemplazar cada coincidencia en input.The replacement parameter specifies the string that is to replace each match in input. replacement puede constar de cualquier combinación de texto literal y sustituciones.replacement can consist of any combination of literal text and substitutions. Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "un *" seguida de la subcadena que coincide con el test captura grupo, si los hay, seguida por la cadena "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". El * no se reconoce el carácter como un metacarácter dentro de un patrón de reemplazo.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Las sustituciones son los elementos del lenguaje de expresión regular solo se reconocen en un patrón de reemplazo.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos los demás elementos de lenguaje de expresiones regulares, incluidos escapes de carácter, se permiten en los patrones de expresión regular solo y no se reconocen en los patrones de reemplazo.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

El matchTimeout parámetro especifica cómo larga una coincidencia de método debe intentar buscar una coincidencia antes de expirar. Establecer un intervalo de tiempo de espera evita que las expresiones regulares que se basan en un retroceso excesivo aparezcan deje de responder al procesar la entrada que contenga cerca de coincidencias.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Para obtener más información, consulte procedimientos recomendados con expresiones regulares y retroceso.For more information, see Best Practices for Regular Expressions and Backtracking. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una RegexMatchTimeoutException excepción.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Notas a los autores de las llamadas

Se recomienda que establezca el matchTimeout parámetro a un valor apropiado, como dos segundos. We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si deshabilita los tiempos de espera mediante la especificación de InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Sin embargo, debe deshabilitar los tiempos de espera solo en las siguientes condiciones: However, you should disable time-outs only under the following conditions: -Cuando la entrada procesada por una expresión regular se deriva de una fuente conocida y de confianza o consta de texto estático. - When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Excluye el texto que ha sido dinámicamente por usuarios. This excludes text that has been dynamically input by users. -Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla con gran eficacia coincide, la ausencia de coincidencias y próximo coincide con. - When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches. -Cuando el patrón de expresión regular contiene ningún elemento de lenguaje que causan un retroceso excesivo al procesar a una coincidencia casi. - When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Consultar también

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

En una subcadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un modelo de expresión regular por una cadena devuelta por un delegado MatchEvaluator. In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string
Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo. A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32 Int32 Int32 Int32

Número máximo de veces que se llevará a cabo el reemplazo. The maximum number of times the replacement will occur.

startat
Int32 Int32 Int32 Int32

Posición del carácter en la cadena de entrada donde comienza la búsqueda. The character position in the input string where the search begins.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

El valor de input o evaluator es null. input or evaluator is null.

startat es menor que cero o mayor que la longitud de input. startat is less than zero or greater than the length of input.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Comentarios

El Regex.Replace(String, MatchEvaluator, Int32, Int32) método es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:The Regex.Replace(String, MatchEvaluator, Int32, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresión regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Los resultados de la cadena de reemplazo de algunos procesos realizados en la cadena coincidente.The replacement string results from some processing done on the matched string.

  • Los resultados de la cadena de reemplazo de un procesamiento condicional.The replacement string results from conditional processing.

El método es equivalente a llamar a la Regex.Matches(String, Int32) método y pasando la primera count Match objetos en el valor devuelto MatchCollection colección a la evaluator delegar.The method is equivalent to calling the Regex.Matches(String, Int32) method and passing the first countMatch objects in the returned MatchCollection collection to the evaluator delegate.

La expresión regular es el patrón definido por el constructor actual Regex objeto.The regular expression is the pattern defined by the constructor for the current Regex object.

El evaluator parámetro es el delegado de un método personalizado que define y que examina cada coincidencia.The evaluator parameter is the delegate for a custom method that you define and that examines each match. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegar.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.Your custom method returns a string that replaces the matched input.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, la excepción se produce si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que el Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no hay tiempo de espera se define en el Regex llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepciónIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Consultar también

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. Las opciones especificadas modifican la operación de coincidencia. Specified options modify the matching operation.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias. The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo. A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia. A bitwise combination of the enumeration values that provide options for matching.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

Se produjo un error de análisis de expresión regular. A regular expression parsing error occurred.

input, pattern o evaluator es null. input, pattern, or evaluator is null.

options no es una combinación bit a bit válida de valores RegexOptions. options is not a valid bitwise combination of RegexOptions values.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

El ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, usa un MatchEvaluator delegado para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. Para ello, el WordScramble método crea una matriz que contiene los caracteres de la coincidencia.To do this, the WordScramble method creates an array that contains the characters in the match. También se crea una matriz paralela que se rellena con números de punto flotante aleatorios.It also creates a parallel array that it populates with random floating-point numbers. Las matrices se ordenan mediante una llamada a la Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método y la matriz ordenada se proporciona como argumento a un String constructor de clase.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. A continuación, se devuelve esta cadena recién creada por el WordScramble método.This newly created string is then returned by the WordScramble method. El patrón de expresión regular \w+ coincide con uno o más caracteres alfabéticos; el motor de expresiones regulares continuará agregando caracteres a la coincidencia hasta que encuentra un carácter que no sea de palabra, como un carácter de espacio en blanco.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character. La llamada a la Replace(String, String, MatchEvaluator, RegexOptions) método incluye el RegexOptions.IgnorePatternWhitespace opción para que el comentario en el patrón de expresión regular \w+ # Matches all the characters in a word. omitido por el motor de expresiones regulares.The call to the Replace(String, String, MatchEvaluator, RegexOptions) method includes the RegexOptions.IgnorePatternWhitespace option so that the comment in the regular expression pattern \w+ # Matches all the characters in a word. is ignored by the regular expression engine.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                      RegexOptions.IgnorePatternWhitespace))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Comentarios

El Regex.Replace(String, String, MatchEvaluator, RegexOptions) método es útil para reemplazar una coincidencia de expresión regular en si se cumple alguna de las condiciones siguientes:The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match in if any of the following conditions is true:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresión regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Los resultados de la cadena de reemplazo de algunos procesos realizados en la cadena coincidente.The replacement string results from some processing done on the matched string.

  • Los resultados de la cadena de reemplazo de un procesamiento condicional.The replacement string results from conditional processing.

El método es equivalente a llamar a la Regex.Matches(String, String, RegexOptions) método y pasar cada Match objeto en el valor devuelto MatchCollection colección a la evaluator delegar.The method is equivalent to calling the Regex.Matches(String, String, RegexOptions) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

El pattern parámetro consta de los elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET Framework y lenguaje de expresiones regulares - referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

El evaluator parámetro es el delegado de un método personalizado que define y que examina cada coincidencia.The evaluator parameter is the delegate for a custom method that you define and that examines each match. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegar.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.Your custom method returns a string that replaces the matched input.

Si especifica RightToLeft para el options parámetro, la búsqueda de coincidencias empieza al final de la cadena de entrada y se mueve a la izquierda; en caso contrario, la búsqueda comienza al principio de la cadena de entrada y se desplaza hacia la derecha.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Si no hay tiempo de espera se define en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepción.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Consultar también

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

En una subcadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada. In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count, int startat);
public string Replace (string input, string replacement, int count, int startat);
member this.Replace : string * string * int * int -> string
Public Function Replace (input As String, replacement As String, count As Integer, startat As Integer) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

replacement
String String String String

La cadena de reemplazo. The replacement string.

count
Int32 Int32 Int32 Int32

Número máximo de veces que puede producirse el reemplazo. Maximum number of times the replacement can occur.

startat
Int32 Int32 Int32 Int32

Posición del carácter en la cadena de entrada donde comienza la búsqueda. The character position in the input string where the search begins.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

El valor de input o replacement es null. input or replacement is null.

startat es menor que cero o mayor que la longitud de input. startat is less than zero or greater than the length of input.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

El ejemplo siguiente se duplica todas excepto la primera línea de una cadena.The following example double-spaces all but the first line of a string. Define un patrón de expresión regular, ^.*$, que coincide con una línea de texto, las llamadas del Match(String) método para que coincida con la primera línea de la cadena y usa el Match.Index y Match.Count propiedades para determinar la posición inicial del segundo línea.It defines a regular expression pattern, ^.*$, that matches a line of text, calls the Match(String) method to match the first line of the string, and uses the Match.Index and Match.Count properties to determine the starting position of the second line.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Instantiating a New Type\n" +
                     "Generally, there are two ways that an\n" + 
                     "instance of a class or structure can\n" +
                     "be instantiated. ";
      string pattern = "^.*$";
      string replacement = "\n$&";
      Regex rgx = new Regex(pattern, RegexOptions.Multiline);
      string result = String.Empty; 
      
      Match match = rgx.Match(input);
      // Double space all but the first line.
      if (match.Success) 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1);

      Console.WriteLine(result);                     
   }
}
// The example displays the following output:
//       Instantiating a New Type
//       
//       Generally, there are two ways that an
//       
//       instance of a class or structure can
//       
//       be instntiated.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Instantiating a New Type" + vbCrLf + _
                            "Generally, there are two ways that an" + vbCrLf + _
                            "instance of a class or structure can" + vbCrLf + _
                            "be instantiated. "
      Dim pattern As String = "^.*$"
      Dim replacement As String = vbCrLf + "$&"
      Dim rgx As New Regex(pattern, RegexOptions.Multiline)
      Dim result As String = String.Empty 
      
      Dim match As Match = rgx.Match(input)
      ' Double space all but the first line.
      If match.Success Then 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1)
      End If
      Console.WriteLine(result)                      
   End Sub
End Module
' The example displays the following output:
'       Instantiating a New Type
'       
'       Generally, there are two ways that an
'       
'       instance of a class or structure can
'       
'       be instntiated.

El patrón de expresión regular ^.*$ se define como se muestra en la tabla siguiente.The regular expression pattern ^.*$ is defined as shown in the following table.

ModeloPattern DescripciónDescription
^ Coincide con el inicio de una línea.Match the start of a line. (Tenga en cuenta que el Regex se crea una instancia del objeto utilizando el RegexOptions.Multiline option; en caso contrario, esta clase de caracteres solo coincidiría con el principio de la cadena de entrada.)(Note that the Regex object was instantiated by using the RegexOptions.Multiline option; otherwise, this character class would only match the beginning of the input string.)
.* Coincide con cualquier carácter cero o más veces.Match any character zero or more times.
$ Coincidir con el final de una línea.Match the end of a line. (Tenga en cuenta que el Regex se crea una instancia del objeto utilizando el RegexOptions.Multiline option; en caso contrario, esta clase de caracteres solo coincidiría con el principio de la cadena de entrada.)(Note that the Regex object was instantiated by using the RegexOptions.Multiline option; otherwise, this character class would only match the beginning of the input string.)

La cadena de reemplazo (vbCrLf + "$&" en Visual Basic, "\n$&" en C#) agrega una nueva línea antes de la cadena coincidente.The replacement string (vbCrLf + "$&" in Visual Basic, "\n$&" in C#) adds a new line before the matched string. Tenga en cuenta que \n en C# en el ejemplo se se interpreta como carácter de nueva línea por el compilador de C#; no representa un carácter de escape de expresión regular.Note that \n in the C# example is interpreted as the newline character by the C# compiler; it does not represent a regular expression character escape.

Comentarios

Se inicia la búsqueda de coincidencias en el input cadena en la posición especificada por el startat parámetro.The search for matches starts in the input string at the position specified by the startat parameter. La expresión regular es el patrón definido por el constructor actual Regex objeto.The regular expression is the pattern defined by the constructor for the current Regex object. Si count es negativo, los reemplazos continuarán hasta el final de la cadena.If count is negative, replacements continue to the end of the string. Si count supera el número de coincidencias, se reemplazan todas las coincidencias.If count exceeds the number of matches, all matches are replaced.

El replacement parámetro especifica la cadena que va a reemplazar cada coincidencia en input.The replacement parameter specifies the string that is to replace each match in input. replacement puede constar de cualquier combinación de texto literal y sustituciones.replacement can consist of any combination of literal text and substitutions. Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "un *" seguida de la subcadena que coincide con el test captura grupo, si los hay, seguida por la cadena "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". El * no se reconoce el carácter como un metacarácter dentro de un patrón de reemplazo.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Las sustituciones son los elementos del lenguaje de expresión regular solo se reconocen en un patrón de reemplazo.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos los demás elementos de lenguaje de expresiones regulares, incluidos escapes de carácter, se permiten en los patrones de expresión regular solo y no se reconocen en los patrones de reemplazo.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, la excepción se produce si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que el Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no hay tiempo de espera se define en el Regex llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepciónIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Consultar también

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. Las opciones especificadas modifican la operación de coincidencia. Specified options modify the matching operation.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options);
public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options);
static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias. The regular expression pattern to match.

replacement
String String String String

La cadena de reemplazo. The replacement string.

options
RegexOptions RegexOptions RegexOptions RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia. A bitwise combination of the enumeration values that provide options for matching.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

Se produjo un error de análisis de expresión regular. A regular expression parsing error occurred.

input, pattern o replacement es null. input, pattern, or replacement is null.

options no es una combinación bit a bit válida de valores RegexOptions. options is not a valid bitwise combination of RegexOptions values.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo siguiente se usa el Replace(String, String, String, RegexOptions) método para reemplazar los nombres de equipo y la unidad locales en una ruta de acceso UNC con una ruta de acceso de archivo local.The following example uses the Replace(String, String, String, RegexOptions) method to replace the local machine and drive names in a UNC path with a local file path. La expresión regular usa el Environment.MachineName propiedad para incluir el nombre del equipo local y el Environment.GetLogicalDrives método para incluir los nombres de las unidades lógicas.The regular expression uses the Environment.MachineName property to include the name of the local computer, and the Environment.GetLogicalDrives method to include the names of the logical drives. Todas las comparaciones de cadenas de expresiones regulares distinguen mayúsculas de minúsculas.All regular expression string comparisons are case-insensitive. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" con el nombre del equipo local.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

using System;
using System.Text.RegularExpressions;

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

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

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

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

El patrón de expresión regular se define mediante la siguiente expresión:The regular expression pattern is defined by the following expression:

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

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.The following table shows how the regular expression pattern is interpreted.

ModeloPattern DescripciónDescription
\\\\ Barra diagonal inversa de coincidencia dos consecutivo (\) caracteres.Match two consecutive backslash (\) characters. Dado que el carácter de barra diagonal inversa se interpreta como carácter de escape, cada barra diagonal inversa debe ser de escape con otra barra diagonal inversa.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Coincide con la cadena devuelta por la Environment.MachineName propiedad.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Coincide con el período (.) carácter seguido de uno o más caracteres alfabéticos.Match the period (.) character followed by one or more word characters. Esta coincidencia puede aparecer cero o más veces.This match can occur zero or more times. No se captura la subexpresión coincidente.The matched subexpression is not captured.
\\ Coincide con una barra diagonal inversa (\) caracteres.Match a backslash (\) character.
([" + driveNames + "]) Coincide con la clase de caracteres formado por las letras de unidad individuales.Match the character class that consists of the individual drive letters. Esta coincidencia es la primera subexpresión capturada.This match is the first captured subexpression.
\$ Coincide con el signo de dólar literal ($) caracteres.Match the literal dollar sign ($) character.

El patrón de reemplazo $1 reemplaza toda la coincidencia con la primera subexpresión capturada.The replacement pattern $1 replaces the entire match with the first captured subexpression. Es decir, reemplaza el nombre de equipo y la unidad UNC con la letra de unidad.That is, it replaces the UNC machine and drive name with the drive letter.

Comentarios

Estático Replace métodos son equivalentes a construir un Regex con el patrón de expresión regular especificada de objetos y llamar al método de instancia Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

El pattern parámetro consta de los elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET Framework y lenguaje de expresiones regulares - referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Si especifica RightToLeft para el options parámetro, la búsqueda de coincidencias empieza al final de la cadena de entrada y se mueve a la izquierda; en caso contrario, la búsqueda comienza al principio de la cadena de entrada y se desplaza hacia la derecha.If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

El replacement parámetro especifica la cadena que va a reemplazar cada coincidencia en input.The replacement parameter specifies the string that is to replace each match in input. replacement puede constar de cualquier combinación de texto literal y sustituciones.replacement can consist of any combination of literal text and substitutions. Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "un *" seguida de la subcadena que coincide con el test captura grupo, si los hay, seguida por la cadena "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". El * no se reconoce el carácter como un metacarácter dentro de un patrón de reemplazo.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Las sustituciones son los elementos del lenguaje de expresión regular solo se reconocen en un patrón de reemplazo.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos los demás elementos de lenguaje de expresiones regulares, incluidos escapes de carácter, se permiten en los patrones de expresión regular solo y no se reconocen en los patrones de reemplazo.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Si no hay tiempo de espera se define en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepción.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Notas a los autores de las llamadas

Este método se agota después de un intervalo que es igual que el valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, el valor InfiniteMatchTimeout, que impide que el método de tiempo de espera, se utiliza. If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para reemplazar una coincidencia de patrones es Replace(String, String, String, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera. The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Consultar también

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);
public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator);
static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string
Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias. The regular expression pattern to match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo. A custom method that examines each match and returns either the original matched string or a replacement string.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

Se produjo un error de análisis de expresión regular. A regular expression parsing error occurred.

input, pattern o evaluator es null. input, pattern, or evaluator is null.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

El ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, usa un MatchEvaluator delegado para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. Para ello, el WordScramble método crea una matriz que contiene los caracteres de la coincidencia.To do this, the WordScramble method creates an array that contains the characters in the match. También se crea una matriz paralela que se rellena con números de punto flotante aleatorios.It also creates a parallel array that it populates with random floating-point numbers. Las matrices se ordenan mediante una llamada a la Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método y la matriz ordenada se proporciona como argumento a un String constructor de clase.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. A continuación, se devuelve esta cadena recién creada por el WordScramble método.This newly created string is then returned by the WordScramble method. El patrón de expresión regular \w+ coincide con uno o más caracteres alfabéticos; el motor de expresiones regulares continuará agregando caracteres a la coincidencia hasta que encuentra un carácter que no sea de palabra, como un carácter de espacio en blanco.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+"                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Comentarios

El Regex.Replace(String, String, MatchEvaluator) método es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:The Regex.Replace(String, String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresión regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Los resultados de la cadena de reemplazo de algunos procesos realizados en la cadena coincidente.The replacement string results from some processing done on the matched string.

  • Los resultados de la cadena de reemplazo de un procesamiento condicional.The replacement string results from conditional processing.

El método es equivalente a llamar a la Regex.Matches(String, String) método y pasar cada Match objeto en el valor devuelto MatchCollection colección a la evaluator delegar.The method is equivalent to calling the Regex.Matches(String, String) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

El pattern parámetro consta de los elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET Framework y lenguaje de expresiones regulares - referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

El evaluator parámetro es el delegado de un método personalizado que define y que examina cada coincidencia.The evaluator parameter is the delegate for a custom method that you define and that examines each match. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegar.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.Your custom method returns a string that replaces the matched input.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Si no hay tiempo de espera se define en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepción.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Notas a los autores de las llamadas

Este método se agota después de un intervalo que es igual que el valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, el valor InfiniteMatchTimeout, que impide que el método de tiempo de espera, se utiliza. If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para evaluar y reemplazar una coincidencia de patrones es Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera. The recommended static method for evaluating and replacing a pattern match is Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), which lets you set the time-out interval.

Consultar también

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular concreta por la cadena de reemplazo indicada. In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement);
public static string Replace (string input, string pattern, string replacement);
static member Replace : string * string * string -> string
Public Shared Function Replace (input As String, pattern As String, replacement As String) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

pattern
String String String String

Patrón de expresión regular del que van a buscarse coincidencias. The regular expression pattern to match.

replacement
String String String String

La cadena de reemplazo. The replacement string.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

Se produjo un error de análisis de expresión regular. A regular expression parsing error occurred.

input, pattern o replacement es null. input, pattern, or replacement is null.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo siguiente se define una expresión regular, \s+, que coincide con uno o varios caracteres de espacio en blanco.The following example defines a regular expression, \s+, that matches one or more white-space characters. La cadena de reemplazo, "", los reemplaza con un carácter de espacio único.The replacement string, " ", replaces them with a single space character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      string result = Regex.Replace(input, pattern, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim result As String = Regex.Replace(input, pattern, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

En el ejemplo siguiente se usa el Replace(String, String, String) método para reemplazar los nombres de equipo y la unidad locales en una ruta de acceso UNC con una ruta de acceso de archivo local.The following example uses the Replace(String, String, String) method to replace the local machine and drive names in a UNC path with a local file path. La expresión regular usa el Environment.MachineName propiedad para incluir el nombre del equipo local y el Environment.GetLogicalDrives método para incluir los nombres de las unidades lógicas.The regular expression uses the Environment.MachineName property to include the name of the local computer, and the Environment.GetLogicalDrives method to include the names of the logical drives. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" con el nombre del equipo local.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

using System;
using System.Text.RegularExpressions;

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

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

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

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

El patrón de expresión regular se define mediante la siguiente expresión:The regular expression pattern is defined by the following expression:

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

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.The following table shows how the regular expression pattern is interpreted.

ModeloPattern DescripciónDescription
\\\\ Barra diagonal inversa de coincidencia dos consecutivo (\) caracteres.Match two consecutive backslash (\) characters. Dado que el carácter de barra diagonal inversa se interpreta como carácter de escape, cada barra diagonal inversa debe ser de escape con otra barra diagonal inversa.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
(?i:" + Environment.MachineName + ") Realizar una coincidencia de mayúsculas y minúsculas de la cadena devuelta por la Environment.MachineName propiedad.Perform a case-insensitive match of the string that is returned by the Environment.MachineName property.
(?:\.\w+)* Coincide con el período (.) carácter seguido de uno o más caracteres alfabéticos.Match the period (.) character followed by one or more word characters. Esta coincidencia puede aparecer cero o más veces.This match can occur zero or more times. No se captura la subexpresión coincidente.The matched subexpression is not captured.
\\ Coincide con una barra diagonal inversa (\) caracteres.Match a backslash (\) character.
((?i:[" + driveNames + "])) Realizar a una coincidencia de mayúsculas y minúsculas de la clase de caracteres que se compone de la comparación de unidad individual.Perform a case-insensitive match of the character class that consists of the individual drive lettters. Esta coincidencia es la primera subexpresión capturada.This match is the first captured subexpression.
\$ Coincide con el signo de dólar literal ($) caracteres.Match the literal dollar sign ($) character.

El patrón de reemplazo $1 reemplaza toda la coincidencia con la primera subexpresión capturada.The replacement pattern $1 replaces the entire match with the first captured subexpression. Es decir, reemplaza el nombre de equipo y la unidad UNC con la letra de unidad.That is, it replaces the UNC machine and drive name with the drive letter.

Comentarios

Estático Replace métodos son equivalentes a construir un Regex con el patrón de expresión regular especificada de objetos y llamar al método de instancia Replace.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

El pattern parámetro consta de los elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET Framework y lenguaje de expresiones regulares - referencia rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. Comienza la búsqueda de coincidencias al principio de la input cadena.The search for matches starts at the beginning of the input string.

El replacement parámetro especifica la cadena que va a reemplazar cada coincidencia en input.The replacement parameter specifies the string that is to replace each match in input. replacement puede constar de cualquier combinación de texto literal y sustituciones.replacement can consist of any combination of literal text and substitutions. Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "un *" seguida de la subcadena que coincide con el test captura grupo, si los hay, seguida por la cadena "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". El * no se reconoce el carácter como un metacarácter dentro de un patrón de reemplazo.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Las sustituciones son los elementos del lenguaje de expresión regular solo se reconocen en un patrón de reemplazo.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos los demás elementos de lenguaje de expresiones regulares, incluidos escapes de carácter, se permiten en los patrones de expresión regular solo y no se reconocen en los patrones de reemplazo.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. Si no hay tiempo de espera se define en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepción.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Notas a los autores de las llamadas

Este método se agota después de un intervalo que es igual que el valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, el valor InfiniteMatchTimeout, que impide que el método de tiempo de espera, se utiliza. If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. El método estático recomendado para reemplazar una coincidencia de patrones es Replace(String, String, String, RegexOptions, TimeSpan), que permite establecer el intervalo de tiempo de espera. The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

Consultar también

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

En una cadena de entrada especificada, reemplaza un número máximo indicado de cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada. In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count);
public string Replace (string input, string replacement, int count);
member this.Replace : string * string * int -> string
Public Function Replace (input As String, replacement As String, count As Integer) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

replacement
String String String String

La cadena de reemplazo. The replacement string.

count
Int32 Int32 Int32 Int32

Número máximo de veces que puede producirse el reemplazo. The maximum number of times the replacement can occur.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

El valor de input o replacement es null. input or replacement is null.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

El siguiente ejemplo reemplaza las cinco primeras apariciones de caracteres duplicados con un solo carácter.The following example replaces the first five occurrences of duplicated characters with a single character. El patrón de expresión regular (\w)\1 detecta instancias consecutivas de un solo carácter y asigna la primera aparición en el primer grupo de captura.The regular expression pattern (\w)\1 matches consecutive occurrences of a single character and assigns the first occurrence to the first capturing group. El patrón de reemplazo $1 reemplaza toda la coincidencia con el primer grupo capturado.The replacement pattern $1 replaces the entire match with the first captured group.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string str = "aabccdeefgghiijkklmm";
      string pattern = "(\\w)\\1"; 
      string replacement = "$1"; 
      Regex rgx = new Regex(pattern);

      string result = rgx.Replace(str, replacement, 5);
      Console.WriteLine("Original String:    '{0}'", str);
      Console.WriteLine("Replacement String: '{0}'", result); 
   }
}
// The example displays the following output:
//       Original String:    'aabccdeefgghiijkklmm'
//       Replacement String: 'abcdefghijkklmm'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim str As String = "aabccdeefgghiijkklmm"
      Dim pattern As String = "(\w)\1" 
      Dim replacement As String = "$1" 
      Dim rgx As New Regex(pattern)

      Dim result As String = rgx.Replace(str, replacement, 5)
      Console.WriteLine("Original String:    '{0}'", str)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    'aabccdeefgghiijkklmm'
'       Replacement String: 'abcdefghijkklmm'

Comentarios

Comienza la búsqueda de coincidencias al principio de la input cadena.The search for matches starts at the beginning of the input string. La expresión regular es el patrón que se define mediante el constructor actual Regex objeto.The regular expression is the pattern that is defined by the constructor for the current Regex object. Si count es negativo, los reemplazos continuarán hasta el final de la cadena.If count is negative, replacements continue to the end of the string. Si count supera el número de coincidencias, se reemplazan todas las coincidencias.If count exceeds the number of matches, all matches are replaced.

El replacement parámetro especifica la cadena que va a reemplazar la primera count coincidencias en input.The replacement parameter specifies the string that is to replace the first count matches in input. replacement puede constar de cualquier combinación de texto literal y sustituciones.replacement can consist of any combination of literal text and substitutions. Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "un *" seguida de la subcadena que coincide con el test captura grupo, si los hay, seguida por la cadena "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". El * no se reconoce el carácter como un metacarácter dentro de un patrón de reemplazo.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Las sustituciones son los elementos del lenguaje de expresión regular solo se reconocen en un patrón de reemplazo.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos los demás elementos de lenguaje de expresiones regulares, incluidos escapes de carácter, se permiten en los patrones de expresión regular solo y no se reconocen en los patrones de reemplazo.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, la excepción se produce si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que el Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no hay tiempo de espera se define en el Regex llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepciónIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Consultar también

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string
Public Function Replace (input As String, evaluator As MatchEvaluator) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo. A custom method that examines each match and returns either the original matched string or a replacement string.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

El valor de input o evaluator es null. input or evaluator is null.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo de código siguiente se muestra una cadena original, coincide con cada palabra en la cadena original, convierte el primer carácter de cada coincidencia en mayúsculas, a continuación, muestra la cadena convertida.The following code example displays an original string, matches each word in the original string, converts the first character of each match to uppercase, then displays the converted string.

using System;
using System.Text.RegularExpressions;

class RegExSample
{
    static string CapText(Match m)
    {
        // Get the matched string.
        string x = m.ToString();
        // If the first char is lower case...
        if (char.IsLower(x[0]))
        {
            // Capitalize it.
            return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
        }
        return x;
    }

    static void Main()
    {
        string text = "four score and seven years ago";

        System.Console.WriteLine("text=[" + text + "]");

        Regex rx = new Regex(@"\w+");

        string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));
        
        System.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"

        System.Console.WriteLine("text=[" & text & "]")

        Dim rx As New Regex("\w+")

        Dim result As String = rx.Replace(text, AddressOf RegExSample.CapText)

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

Comentarios

El Regex.Replace(String, MatchEvaluator) método es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:The Regex.Replace(String, MatchEvaluator) method is useful for replacing a regular expression match if any of the following conditions is true:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresión regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Los resultados de la cadena de reemplazo de algunos procesos realizados en la cadena coincidente.The replacement string results from some processing done on the matched string.

  • Los resultados de la cadena de reemplazo de un procesamiento condicional.The replacement string results from conditional processing.

El método es equivalente a llamar a la Regex.Matches(String) método y pasar cada Match objeto en el valor devuelto MatchCollection colección a la evaluator delegar.The method is equivalent to calling the Regex.Matches(String) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

La expresión regular es el patrón definido por el constructor actual Regex objeto.The regular expression is the pattern defined by the constructor for the current Regex object.

El evaluator parámetro es el delegado de un método personalizado que define y que examina cada coincidencia.The evaluator parameter is the delegate for a custom method that you define and that examines each match. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegar.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.Your custom method returns a string that replaces the matched input.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, la excepción se produce si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que el Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no hay tiempo de espera se define en el Regex llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepciónIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Consultar también

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

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada. In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement);
public string Replace (string input, string replacement);
member this.Replace : string * string -> string
Public Function Replace (input As String, replacement As String) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

replacement
String String String String

La cadena de reemplazo. The replacement string.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that the replacement string takes the place of each matched string. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

El valor de input o replacement es null. input or replacement is null.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

En el ejemplo siguiente se define una expresión regular, \s+, que coincide con uno o varios caracteres de espacio en blanco.The following example defines a regular expression, \s+, that matches one or more white-space characters. La cadena de reemplazo, "", los reemplaza con un carácter de espacio único.The replacement string, " ", replaces them with a single space character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

En el ejemplo siguiente se define una expresión regular, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?y un patrón de reemplazo, $2, que quita caracteres iniciales o un símbolo de divisa al final de un valor numérico.The following example defines a regular expression, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?, and a replacement pattern, $2, that removes either a leading or a trailing currency symbol from a numeric value.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern =  @"(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?";
      string input = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17";
      string replacement = "$2";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);

      Console.WriteLine("Original String:    '{0}'", input);
      Console.WriteLine("Replacement String: '{0}'", result);                             
   }
}
// The example displays the following output:
//       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
//       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String =  "(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?"
      Dim input As String = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17"
      Dim replacement As String = "$2"
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)

      Console.WriteLine("Original String:    '{0}'", input)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
'       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

La expresión regular se interpreta como se muestra en la tabla siguiente.The regular expression is interpreted as shown in the following table.

ModeloPattern DescripciónDescription
\p{Sc} Coincide con un símbolo de moneda.Match a currency symbol. {Sc} denota cualquier carácter que sea miembro del símbolo Unicode, categoría de moneda.{Sc} denotes any character that is a member of the Unicode Symbol, Currency category.
\s? Busca coincidencias con cero o un carácter de espacio en blanco.Match zero or one white-space character.
(\p{Sc}\s?)? Coincide con cero o una aparición de la combinación de un símbolo de moneda seguido de cero o un carácter de espacio en blanco.Match zero or one occurrence of the combination of a currency symbol followed by zero or one white-space character. Este es el primer grupo de captura.This is the first capturing group.
\d+ Buscar coincidencias con uno o más dígitos decimales.Match one or more decimal digits.
\.? Coincide con cero o una aparición de un período (que se usa como un carácter de separador decimal).Match zero or one occurrence of a period (used as a decimal separator character).
((?<=\.)\d+)? Si un punto es el carácter anterior, coincide con uno o más dígitos decimales.If a period is the previous character, match one or more decimal digits. Este patrón puede coincidir cero o una vez.This pattern can be matched either zero or one time.
(\d+\.?((?<=\.)\d+)?) Coincide con el patrón de uno o más dígitos decimales, seguido de un punto opcional y los dígitos decimales adicionales.Match the pattern of one or more decimal digits followed by an optional period and additional decimal digits. Este es el segundo grupo de captura.This is the second capturing group. La llamada a la Replace(String, String) método reemplaza toda la coincidencia con el valor de este grupo capturado.The call to the Replace(String, String) method replaces the entire match with the value of this captured group.
(?(1)&#124;\s?\p{Sc})? Si el primer grupo capturado existe, coincide con una cadena vacía.If the first captured group exists, match an empty string. En caso contrario, coincide con cero o un carácter de espacio en blanco seguido de un símbolo de moneda.Otherwise, match zero or one white-space character followed by a currency symbol.

Comentarios

Comienza la búsqueda de coincidencias al principio de la input cadena.The search for matches starts at the beginning of the input string. La expresión regular es el patrón definido por el constructor actual Regex objeto.The regular expression is the pattern defined by the constructor for the current Regex object.

El replacement parámetro especifica la cadena que va a reemplazar cada coincidencia en input.The replacement parameter specifies the string that is to replace each match in input. replacement puede constar de cualquier combinación de texto literal y sustituciones.replacement can consist of any combination of literal text and substitutions. Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "un *" seguida de la subcadena que coincide con el test captura grupo, si los hay, seguida por la cadena "b".For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". El * no se reconoce el carácter como un metacarácter dentro de un patrón de reemplazo.The * character is not recognized as a metacharacter within a replacement pattern.

Nota

Las sustituciones son los elementos del lenguaje de expresión regular solo se reconocen en un patrón de reemplazo.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. Todos los demás elementos de lenguaje de expresiones regulares, incluidos escapes de carácter, se permiten en los patrones de expresión regular solo y no se reconocen en los patrones de reemplazo.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, la excepción se produce si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que el Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no hay tiempo de espera se define en el Regex llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepciónIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Consultar también

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

En una cadena de entrada especificada, reemplaza un número máximo especificado de cadenas que coinciden con un modelo de expresión regular por una cadena devuelta por un delegado MatchEvaluator. In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);
public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);
member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string
Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String
Parámetros
input
String String String String

Cadena en la que se va a buscar una coincidencia. The string to search for a match.

evaluator
MatchEvaluator MatchEvaluator MatchEvaluator MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo. A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32 Int32 Int32 Int32

Número máximo de veces que se llevará a cabo el reemplazo. The maximum number of times the replacement will occur.

Devoluciones

Cadena nueva que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo ocupa el lugar de cada cadena coincidente. A new string that is identical to the input string, except that a replacement string takes the place of each matched string. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Excepciones

El valor de input o evaluator es null. input or evaluator is null.

Se agotó el tiempo de espera. A time-out occurred. Para más información sobre los tiempos de espera, vea la sección Comentarios. For more information about time-outs, see the Remarks section.

Ejemplos

El ejemplo siguiente usa una expresión regular para escribir mal deliberadamente a mitad de las palabras de una lista.The following example uses a regular expression to deliberately misspell half of the words in a list. Se usa la expresión regular \w*(ie|ei)\w* para buscar palabras que incluyen los caracteres "ie" o "ei".It uses the regular expression \w*(ie|ei)\w* to match words that include the characters "ie" or "ei". Pasa la primera mitad de las palabras coincidentes del ReverseLetter método, que, a su vez, se usa el Replace(String, String, String, RegexOptions) para invertir la "i" y "e" en la cadena coincidente.It passes the first half of the matching words to the ReverseLetter method, which, in turn, uses the Replace(String, String, String, RegexOptions) method to reverse "i" and "e" in the matched string. El resto de las palabras permanecen sin cambios.The remaining words remain unchanged.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "deceive relieve achieve belief fierce receive";
      string pattern = @"\w*(ie|ei)\w*";
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
      Console.WriteLine("Original string: " + input);
      
      string result = rgx.Replace(input, new MatchEvaluator(Example.ReverseLetter), 
                                  input.Split(' ').Length / 2);
      Console.WriteLine("Returned string: " + result);
   }

   static string ReverseLetter(Match match)
   {
      return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase);            
   }
}
// The example displays the following output:
//    Original string: deceive relieve achieve belief fierce receive
//    Returned string: decieve releive acheive belief fierce receive
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "deceive relieve achieve belief fierce receive"
      Dim pattern As String = "\w*(ie|ei)\w*"
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
      Console.WriteLine("Original string: " + input)
      
      Dim result As String = rgx.Replace(input, AddressOf ReverseLetter, 
                                           input.Split(" "c).Length \ 2)
      Console.WriteLine("Returned string: " + result)
   End Sub

   Public Function ReverseLetter(match As Match) As String
      Return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase)            
   End Function
End Module
' The example displays the following output:
'    Original string: deceive relieve achieve belief fierce receive
'    Returned string: decieve releive acheive belief fierce receive

La expresión regular \w*(ie|ei)\w* se define como se muestra en la tabla siguiente.The regular expression \w*(ie|ei)\w* is defined as shown in the following table.

ModeloPattern DescripciónDescription
\w* Buscar una coincidencia con cero o más caracteres alfabéticos.Match zero or more word characters.
(ie&#124;ei) Coincide con "ie" o "ei".Match either "ie" or "ei".
\w* Buscar una coincidencia con cero o más caracteres alfabéticos.Match zero or more word characters.

El patrón de expresión regular ([ie])([ie]) en el ReverseLetter método coincide con la primera "i" o "e" en el diphthong "ie" o "ei" y asigna la letra al primer grupo de captura.The regular expression pattern ([ie])([ie]) in the ReverseLetter method matches the first "i" or "e" in the diphthong "ie" or "ei" and assigns the letter to the first capturing group. Coincide con la segunda "i" o "e" y asigna la letra al segundo grupo de captura.It matches the second "i" or "e" and assigns the letter to the second capturing group. Los dos caracteres, a continuación, se invierten mediante una llamada a la Replace(String, String, String) método con el patrón de reemplazo $2$1.The two characters are then reversed by calling the Replace(String, String, String) method with the replacement pattern $2$1.

Comentarios

El Regex.Replace(String, MatchEvaluator, Int32) método es útil para reemplazar una coincidencia de expresión regular si se cumple alguna de las condiciones siguientes:The Regex.Replace(String, MatchEvaluator, Int32) method is useful for replacing a regular expression match if any of the following conditions is true:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresión regular.The replacement string cannot readily be specified by a regular expression replacement pattern.

  • Los resultados de la cadena de reemplazo de algunos procesos realizados en la cadena coincidente.The replacement string results from some processing done on the matched string.

  • Los resultados de la cadena de reemplazo de un procesamiento condicional.The replacement string results from conditional processing.

El método es equivalente a llamar a la Regex.Matches(String) método y pasando la primera count Match objetos en el valor devuelto MatchCollection colección a la evaluator delegar.The method is equivalent to calling the Regex.Matches(String) method and passing the first countMatch objects in the returned MatchCollection collection to the evaluator delegate.

La expresión regular es el patrón definido por el constructor actual Regex objeto.The regular expression is the pattern defined by the constructor for the current Regex object.

El evaluator parámetro es el delegado de un método personalizado que define y que examina cada coincidencia.The evaluator parameter is the delegate for a custom method that you define and that examines each match. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegar.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

El método personalizado devuelve una cadena que reemplaza la entrada coincidente.Your custom method returns a string that replaces the matched input.

El RegexMatchTimeoutException es una excepción si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si no establece un intervalo de tiempo de espera al llamar al constructor, la excepción se produce si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que el Regex se crea el objeto.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si no hay tiempo de espera se define en el Regex llamada al constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se produce ninguna excepciónIf no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

Dado que el método devuelve input sin cambios si no hay ninguna coincidencia, puede usar el Object.ReferenceEquals método para determinar si el método ha realizado ningún reemplazo para la cadena de entrada.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

Consultar también

Se aplica a