Regex.Replace Método

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.

Sobrecargas

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.

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.

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

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. Las opciones especificadas modifican la operación de coincidencia.

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

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. Las opciones especificadas modifican la operación de coincidencia.

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.

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.

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.

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.

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.

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.

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.

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

Cadena en la que se va a buscar una coincidencia.

evaluator
MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo.

count
Int32

Número máximo de veces que se llevará a cabo el reemplazo.

startat
Int32

Posición del carácter en la cadena de entrada donde comienza la búsqueda.

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. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar.

Excepciones

input o evaluator es null.

startat es menor que cero o mayor que la longitud de input.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

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:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.
  • La cadena de reemplazo resulta de algún procesamiento realizado en la cadena coincidente.
  • La cadena de reemplazo resulta del procesamiento condicional.

El método es equivalente a llamar al Regex.Matches(String, Int32) método y pasar los primeros countMatch objetos de la colección devuelta MatchCollection al evaluator delegado.

Para obtener más información sobre startat, vea la sección Comentarios de Match(String, Int32).

La expresión regular es el patrón definido por el constructor para el objeto actual Regex .

El evaluator parámetro es el delegado de un método personalizado que se define y que examina cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegado.

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.

La RegexMatchTimeoutException excepción se produce 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. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el Regex objeto. Si no se define ningún tiempo de espera en la llamada del Regex constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Consulte también

Se aplica a

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.

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

Cadena en la que se va a buscar una coincidencia.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.

replacement
String

La cadena de reemplazo.

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. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar.

Excepciones

Se produjo un error de análisis de expresión regular.

input, pattern o replacement es null.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se define una expresión regular, \s+, que coincide con uno o varios caracteres de espacio en blanco. La cadena de reemplazo, " ", las reemplaza por un solo carácter de espacio.

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 el equipo local y los nombres de unidad en una ruta de acceso UNC por una ruta de acceso de archivo local. La expresión regular usa la 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. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" por el nombre del equipo local.

using System;
using System.Text.RegularExpressions;

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

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

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

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

El patrón de expresión regular se define mediante la expresión siguiente:

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

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.

Modelo Descripción
\\\\ Coincide con dos caracteres de barra diagonal inversa consecutivas (\). Dado que el carácter de barra diagonal inversa se interpreta como el carácter de escape, cada barra diagonal inversa debe escaparse con otra barra diagonal inversa.
(?i:" + Environment.MachineName + ") Realice una coincidencia que no distingue mayúsculas de minúsculas de la cadena devuelta por la Environment.MachineName propiedad .
(?:\.\w+)* Coincide con el carácter de punto (.) seguido de uno o más caracteres de palabra. Esta coincidencia puede producirse cero o más veces. La subexpresión coincidente no se captura.
\\ Coincide con un carácter de barra diagonal inversa (\).
((?i:[" + driveNames + "])) Realice una coincidencia sin distinción entre mayúsculas y minúsculas de la clase de caracteres que consta de las letras de unidad individuales. Esta coincidencia es la primera subexpresión capturada.
\$ Coincide con el carácter de signo de dólar literal ($).

El patrón $1 de reemplazo reemplaza toda la coincidencia con la primera subexpresión capturada. Es decir, reemplaza la máquina UNC y el nombre de unidad por la letra de unidad.

Comentarios

Los métodos estáticos Replace son equivalentes a construir un Regex objeto con el patrón de expresión regular especificado y llamar al método Replacede instancia .

El pattern parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea Expresiones regulares de .NET y Lenguaje de expresiones regulares: referencia rápida. La búsqueda de coincidencias comienza al principio de la input cadena.

El replacement parámetro especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones. Por ejemplo, el patrón a*${test}b de reemplazo inserta la cadena "a*" seguida de la subcadena que coincide con el test grupo de captura, si existe, seguida de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

Nota:

Las sustituciones son los únicos elementos del lenguaje de expresiones regulares que se reconocen en un patrón de reemplazo. Todos los demás elementos del lenguaje de expresiones regulares, incluidos los escapes de caracteres, solo se permiten en patrones de expresión regular y no se reconocen en patrones de reemplazo.

La RegexMatchTimeoutException excepción se produce 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 . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que el método agote el tiempo de espera. El método estático recomendado para reemplazar una coincidencia de patrón es Replace(String, String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

Se aplica a

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

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

Cadena en la que se va a buscar una coincidencia.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.

evaluator
MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo.

options
RegexOptions

Combinación bit a bit de los valores de la enumeración que proporcionan opciones de coincidencia.

matchTimeout
TimeSpan

Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.

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. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar.

Excepciones

Se produjo un error de análisis de expresión regular.

input, pattern o evaluator es null.

options no es una combinación bit a bit válida de valores RegexOptions.

O bien

matchTimeout es negativo, cero o mayor que 24 días aproximadamente.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, se usa un MatchEvaluator delegado para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra. Para ello, el WordScramble método crea una matriz que contiene los caracteres de la coincidencia. También crea una matriz paralela que rellena con números de punto flotante aleatorios. Las matrices se ordenan llamando al Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método y la matriz ordenada se proporciona como argumento para un String constructor de clase. A continuación, el WordScramble método devuelve esta cadena recién creada. El patrón \w+ de expresión regular coincide con uno o varios caracteres de palabra; el motor de expresiones regulares seguirá agregando caracteres a la coincidencia hasta que encuentre un carácter que no sea de palabra, como un carácter de espacio en blanco. La llamada al Replace(String, String, MatchEvaluator, RegexOptions) método incluye la RegexOptions.IgnorePatternWhitespace opción para que el motor de expresiones regulares omita el comentario en el patrón \w+ # Matches all the characters in a word. de expresión regular.

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

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

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

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

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:

  • Si la cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

  • Si la cadena de reemplazo resulta de algún procesamiento realizado en la cadena coincidente.

  • Si la cadena de reemplazo resulta del procesamiento condicional.

El método equivale a llamar al Regex.Matches(String, String, RegexOptions) método y pasar cada Match objeto de la colección devuelta MatchCollection al evaluator delegado.

El pattern parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea Expresiones regulares de .NET y Lenguaje de expresiones regulares: referencia rápida.

El evaluator parámetro es el delegado de un método personalizado que se define y que examina cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegado.

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.

Si especifica RightToLeft para el options parámetro , la búsqueda de coincidencias comienza al final de la cadena de entrada y se mueve a la izquierda; de lo contrario, la búsqueda comienza al principio de la cadena de entrada y se mueve a la derecha.

El matchTimeout parámetro especifica cuánto tiempo debe intentar encontrar una coincidencia un método de coincidencia antes de que se agote el tiempo de espera. Establecer un intervalo de tiempo de espera impide que las expresiones regulares que se basan en un retroceso excesivo parezcan "dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea Procedimientos recomendados para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una RegexMatchTimeoutException excepción. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.

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 reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Se recomienda establecer el matchTimeout parámetro en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

  • Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.

  • Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla eficazmente las coincidencias, las no coincide y las coincidencias cercanas.

  • Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

Se aplica a

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. Las opciones especificadas modifican la operación de coincidencia.

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

Cadena en la que se va a buscar una coincidencia.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.

evaluator
MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.

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. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar.

Excepciones

Se produjo un error de análisis de expresión regular.

input, pattern o evaluator es null.

options no es una combinación bit a bit válida de valores RegexOptions.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, se usa un MatchEvaluator delegado para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra. Para ello, el WordScramble método crea una matriz que contiene los caracteres de la coincidencia. También crea una matriz paralela que rellena con números de punto flotante aleatorios. Las matrices se ordenan llamando al Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método y la matriz ordenada se proporciona como argumento para un String constructor de clase. A continuación, el WordScramble método devuelve esta cadena recién creada. El patrón \w+ de expresión regular coincide con uno o varios caracteres de palabra; el motor de expresiones regulares seguirá agregando caracteres a la coincidencia hasta que encuentre un carácter que no sea de palabra, como un carácter de espacio en blanco. La llamada al Replace(String, String, MatchEvaluator, RegexOptions) método incluye la RegexOptions.IgnorePatternWhitespace opción para que el motor de expresiones regulares omita el comentario en el patrón \w+ # Matches all the characters in a word. de expresión regular.

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

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      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:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

  • La cadena de reemplazo resulta de algún procesamiento realizado en la cadena coincidente.

  • La cadena de reemplazo se obtiene del procesamiento condicional.

El método equivale a llamar al Regex.Matches(String, String, RegexOptions) método y pasar cada Match objeto de la colección devuelta MatchCollection al evaluator delegado.

El pattern parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea Expresiones regulares de .NET y Lenguaje de expresiones regulares: referencia rápida.

El evaluator parámetro es el delegado de un método personalizado que se define y que examina cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegado.

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.

Si especifica RightToLeft para el options parámetro , la búsqueda de coincidencias comienza al final de la cadena de entrada y se mueve a la izquierda; de lo contrario, la búsqueda comienza al principio de la cadena de entrada y se mueve a la derecha.

La RegexMatchTimeoutException excepción se produce 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 . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Consulte también

Se aplica a

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

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

Cadena en la que se va a buscar una coincidencia.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.

replacement
String

La cadena de reemplazo.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.

matchTimeout
TimeSpan

Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.

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. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar.

Excepciones

Se produjo un error de análisis de expresión regular.

input, pattern o replacement es null.

options no es una combinación bit a bit válida de valores RegexOptions.

O bien

matchTimeout es negativo, cero o mayor que 24 días aproximadamente.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se usa el Replace(String, String, String, RegexOptions, TimeSpan) método para reemplazar el equipo local y los nombres de unidad en una ruta de acceso UNC por una ruta de acceso de archivo local. La expresión regular usa la 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. Todas las comparaciones de cadenas de expresión regular no distinguen mayúsculas de minúsculas y cualquier operación de reemplazo única agota el tiempo de espera si no se encuentra una coincidencia en 0,5 segundos. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" por el nombre del equipo local.

using System;
using System.Text.RegularExpressions;

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

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

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

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

El patrón de expresión regular se define mediante la expresión siguiente:

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

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.

Modelo Descripción
\\\\ Coincide con dos caracteres de barra diagonal inversa consecutivas (\). Dado que el carácter de barra diagonal inversa se interpreta como el carácter de escape, cada barra diagonal inversa debe escaparse con otra barra diagonal inversa.
+ Environment.MachineName + Coincide con la cadena devuelta por la Environment.MachineName propiedad .
(?:\.\w+)* Coincide con el carácter de punto (.) seguido de uno o más caracteres de palabra. Esta coincidencia puede producirse cero o más veces. La subexpresión coincidente no se captura.
\\ Coincide con un carácter de barra diagonal inversa (\).
([" + driveNames + "]) Coincide con la clase de caracteres que consta de las letras de unidad individuales. Esta coincidencia es la primera subexpresión capturada.
\$ Coincide con el carácter de signo de dólar literal ($).

El patrón $1 de reemplazo reemplaza toda la coincidencia con la primera subexpresión capturada. Es decir, reemplaza la máquina UNC y el nombre de unidad por la letra de unidad.

Comentarios

Los métodos estáticos Replace son equivalentes a construir un Regex objeto con el patrón de expresión regular especificado y llamar al método Replacede instancia .

El pattern parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea Expresiones regulares de .NET y Lenguaje de expresiones regulares: referencia rápida. Si especifica RightToLeft para el options parámetro , la búsqueda de coincidencias comienza al final de la cadena de entrada y se mueve a la izquierda; de lo contrario, la búsqueda comienza al principio de la cadena de entrada y se mueve a la derecha.

El replacement parámetro especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones. Por ejemplo, el patrón a*${test}b de reemplazo inserta la cadena "a*" seguida de la subcadena que coincide con el test grupo de captura, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

Nota:

Las sustituciones son los únicos elementos del lenguaje de expresiones regulares que se reconocen en un patrón de reemplazo. Todos los demás elementos del lenguaje de expresiones regulares, incluidos los escapes de caracteres, solo se permiten en patrones de expresión regular y no se reconocen en patrones de reemplazo.

El matchTimeout parámetro especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que agote el tiempo de espera. Establecer un intervalo de tiempo de espera impide que las expresiones regulares que dependen del retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea Procedimientos recomendados para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una RegexMatchTimeoutException excepción. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.

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 reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Se recomienda establecer el matchTimeout parámetro en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

  • Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.

  • Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla de forma eficaz las coincidencias, las no coincide y las coincidencias cercanas.

  • Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

Se aplica a

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. Las opciones especificadas modifican la operación de coincidencia.

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

Cadena en la que se va a buscar una coincidencia.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.

replacement
String

La cadena de reemplazo.

options
RegexOptions

Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.

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. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar.

Excepciones

Se produjo un error de análisis de expresión regular.

input, pattern o replacement es null.

options no es una combinación bit a bit válida de valores RegexOptions.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se usa el Replace(String, String, String, RegexOptions) método para reemplazar el equipo local y los nombres de unidad en una ruta de acceso UNC por una ruta de acceso de archivo local. La expresión regular usa la 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. Todas las comparaciones de cadenas de expresiones regulares no distinguen mayúsculas de minúsculas. Para ejecutar el ejemplo correctamente, debe reemplazar la cadena literal "MyMachine" por el nombre del equipo local.

using System;
using System.Text.RegularExpressions;

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

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

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

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

El patrón de expresión regular se define mediante la expresión siguiente:

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

En la siguiente tabla se muestra cómo se interpreta el patrón de expresión regular.

Modelo Descripción
\\\\ Coincide con dos caracteres de barra diagonal inversa consecutivas (\). Dado que el carácter de barra diagonal inversa se interpreta como el carácter de escape, cada barra diagonal inversa debe escaparse con otra barra diagonal inversa.
+ Environment.MachineName + Coincide con la cadena devuelta por la Environment.MachineName propiedad .
(?:\.\w+)* Coincide con el carácter de punto (.) seguido de uno o más caracteres de palabra. Esta coincidencia puede producirse cero o más veces. La subexpresión coincidente no se captura.
\\ Coincide con un carácter de barra diagonal inversa (\).
([" + driveNames + "]) Coincide con la clase de caracteres que consta de las letras de unidad individuales. Esta coincidencia es la primera subexpresión capturada.
\$ Coincide con el carácter de signo de dólar literal ($).

El patrón $1 de reemplazo reemplaza toda la coincidencia con la primera subexpresión capturada. Es decir, reemplaza la máquina UNC y el nombre de unidad por la letra de unidad.

Comentarios

Los métodos estáticos Replace son equivalentes a construir un Regex objeto con el patrón de expresión regular especificado y llamar al método Replacede instancia .

El pattern parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea Expresiones regulares de .NET y Lenguaje de expresiones regulares: referencia rápida. Si especifica RightToLeft para el options parámetro , la búsqueda de coincidencias comienza al final de la cadena de entrada y se mueve a la izquierda; de lo contrario, la búsqueda comienza al principio de la cadena de entrada y se mueve a la derecha.

El replacement parámetro especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones. Por ejemplo, el patrón a*${test}b de reemplazo inserta la cadena "a*" seguida de la subcadena que coincide con el test grupo de captura, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

Nota:

Las sustituciones son los únicos elementos del lenguaje de expresiones regulares que se reconocen en un patrón de reemplazo. Todos los demás elementos del lenguaje de expresiones regulares, incluidos los escapes de caracteres, solo se permiten en patrones de expresión regular y no se reconocen en patrones de reemplazo.

La RegexMatchTimeoutException excepción se produce 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 . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que el método agote el tiempo de espera. El método estático recomendado para reemplazar una coincidencia de patrón es Replace(String, String, String, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

Se aplica a

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.

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

Cadena en la que se va a buscar una coincidencia.

evaluator
MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo.

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. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar.

Excepciones

input o evaluator es null.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo de código siguiente se muestra una cadena original, coincide con cada palabra de la cadena original, se convierte el primer carácter de cada coincidencia en mayúsculas y, a continuación, se muestra la cadena convertida.

using System;
using System.Text.RegularExpressions;

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

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

        Console.WriteLine($"text=[{text}]");

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

        string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));

        Console.WriteLine($"result=[{result}]");
    }
}
// The example displays the following output:
//       text=[four score and seven years ago]
//       result=[Four Score And Seven Years Ago]
Imports System.Text.RegularExpressions

Module RegExSample
    Function CapText(ByVal m As Match) As String
        ' Get the matched string.
        Dim x As String = m.ToString()
        ' If the first char is lower case...
        If Char.IsLower(x.Chars(0)) Then
            ' Capitalize it.
            Return Char.ToUpper(x.Chars(0)) & x.Substring(1, x.Length - 1)
        End If
        Return x
    End Function

    Sub Main()
        Dim text As String = "four score and seven years ago"

        Console.WriteLine($"text=[{text}]")

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

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

        Console.WriteLine($"result=[{result}]")
    End Sub
End Module
' The example displays the following output:
'       text=[four score and seven years ago]
'       result=[Four Score And Seven Years Ago]

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:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

  • La cadena de reemplazo resulta de algún procesamiento realizado en la cadena coincidente.

  • La cadena de reemplazo resulta del procesamiento condicional.

El método es equivalente a llamar al Regex.Matches(String) método y pasar cada Match objeto de la colección devuelta MatchCollection al evaluator delegado.

La expresión regular es el patrón definido por el constructor para el objeto actual Regex .

El evaluator parámetro es el delegado de un método personalizado que se define y que examina cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegado.

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.

La RegexMatchTimeoutException excepción se produce 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. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el Regex objeto. Si no se define ningún tiempo de espera en la llamada del Regex constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Consulte también

Se aplica a

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.

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

Cadena en la que se va a buscar una coincidencia.

evaluator
MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo.

count
Int32

Número máximo de veces que se llevará a cabo el reemplazo.

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. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar.

Excepciones

input o evaluator es null.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se usa una expresión regular para mal revender deliberadamente la mitad de las palabras de una lista. Usa la expresión \w*(ie|ei)\w* regular para buscar coincidencias con palabras que incluyan los caracteres "ie" o "ei". Pasa la primera mitad de las palabras coincidentes al ReverseLetter método , que, a su vez, usa el Replace(String, String, String, RegexOptions) método para invertir "i" y "e" en la cadena coincidente. Las palabras restantes permanecen sin cambios.

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.

Modelo Descripción
\w* Buscar una coincidencia con cero o más caracteres alfabéticos.
(ie|ei) Coincide con "ie" o "ei".
\w* Buscar una coincidencia con cero o más caracteres alfabéticos.

El patrón ([ie])([ie]) de expresión regular del ReverseLetter método coincide con el primer "i" o "e" en el diphthong "ie" o "ei" y asigna la letra al primer grupo de captura. Coincide con el segundo "i" o "e" y asigna la letra al segundo grupo de captura. A continuación, los dos caracteres se invierten llamando al Replace(String, String, String) método con el patrón $2$1de reemplazo .

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:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

  • La cadena de reemplazo resulta de algún procesamiento realizado en la cadena coincidente.

  • La cadena de reemplazo resulta del procesamiento condicional.

El método es equivalente a llamar al Regex.Matches(String) método y pasar los primeros countMatch objetos de la colección devuelta MatchCollection al evaluator delegado.

La expresión regular es el patrón definido por el constructor para el objeto actual Regex .

El evaluator parámetro es el delegado de un método personalizado que se define y que examina cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegado.

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.

La RegexMatchTimeoutException excepción se produce 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. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el Regex objeto. Si no se define ningún tiempo de espera en la llamada del Regex constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Consulte también

Se aplica a

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.

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

Cadena en la que se va a buscar una coincidencia.

pattern
String

Patrón de expresión regular del que van a buscarse coincidencias.

evaluator
MatchEvaluator

Un método personalizado que examina cada coincidencia y devuelve la cadena coincidente original o una cadena de reemplazo.

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. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin modificar.

Excepciones

Se produjo un error de análisis de expresión regular.

input, pattern o evaluator es null.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se usa una expresión regular para extraer las palabras individuales de una cadena y, a continuación, se usa un MatchEvaluator delegado para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra. Para ello, el WordScramble método crea una matriz que contiene los caracteres de la coincidencia. También crea una matriz paralela que se rellena con números de punto flotante aleatorios. Las matrices se ordenan llamando al Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) método y la matriz ordenada se proporciona como argumento para un String constructor de clase. A continuación, el WordScramble método devuelve esta cadena recién creada. El patrón \w+ de expresión regular coincide con uno o varios caracteres de palabra; el motor de expresiones regulares seguirá agregando caracteres a la coincidencia hasta que encuentre un carácter que no sea de palabra, como un carácter de espacio en blanco.

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:

  • La cadena de reemplazo no se puede especificar fácilmente mediante un patrón de reemplazo de expresiones regulares.

  • La cadena de reemplazo resulta de algún procesamiento realizado en la cadena coincidente.

  • La cadena de reemplazo resulta del procesamiento condicional.

El método es equivalente a llamar al Regex.Matches(String, String) método y pasar cada Match objeto de la colección devuelta MatchCollection al evaluator delegado.

El pattern parámetro consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea Expresiones regulares de .NET y Lenguaje de expresiones regulares: referencia rápida.

El evaluator parámetro es el delegado de un método personalizado que se define y que examina cada coincidencia. El método personalizado debe tener la siguiente firma para que coincida con el MatchEvaluator delegado.

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.

La RegexMatchTimeoutException excepción se produce 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 . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que el método agote el tiempo de espera. El método estático recomendado para evaluar y reemplazar una coincidencia de patrón es Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

Se aplica a

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.

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

Cadena en la que se va a buscar una coincidencia.

replacement
String

La cadena de reemplazo.

count
Int32

Número máximo de veces que puede producirse el reemplazo.

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. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar.

Excepciones

input o replacement es null.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se reemplazan las cinco primeras repeticiones de caracteres duplicados por un solo carácter. El patrón (\w)\1 de expresión regular coincide con apariciones consecutivas de un solo carácter y asigna la primera aparición al primer grupo de captura. El patrón $1 de reemplazo reemplaza toda la coincidencia con el primer grupo capturado.

using System;
using System.Text.RegularExpressions;

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

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

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

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

Comentarios

La búsqueda de coincidencias comienza al principio de la input cadena. La expresión regular es el patrón definido por el constructor para el objeto actual Regex . Si count es negativo, los reemplazos continúan hasta el final de la cadena. Si count supera el número de coincidencias, se reemplazan todas las coincidencias.

El replacement parámetro especifica la cadena que va a reemplazar las primeras count coincidencias en input. replacement puede constar de cualquier combinación de texto literal y sustituciones. Por ejemplo, el patrón a*${test}b de reemplazo inserta la cadena "a*" seguida de la subcadena que coincide con el test grupo de captura, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

Nota:

Las sustituciones son los únicos elementos del lenguaje de expresiones regulares que se reconocen en un patrón de reemplazo. Todos los demás elementos del lenguaje de expresiones regulares, incluidos los escapes de caracteres, solo se permiten en patrones de expresión regular y no se reconocen en patrones de reemplazo.

La RegexMatchTimeoutException excepción se produce 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. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el Regex objeto. Si no se define ningún tiempo de espera en la llamada del Regex constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Consulte también

Se aplica a

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.

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

Cadena en la que se va a buscar una coincidencia.

replacement
String

La cadena de reemplazo.

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. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar.

Excepciones

input o replacement es null.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se define una expresión regular, \s+, que coincide con uno o varios caracteres de espacio en blanco. La cadena de reemplazo, " ", las reemplaza por un solo carácter de espacio.

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 un símbolo de moneda inicial o final de un valor numérico.

using System;
using System.Text.RegularExpressions;

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

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

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

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

La expresión regular se interpreta como se muestra en la tabla siguiente.

Patrón Descripción
\p{Sc} Coincide con un símbolo de moneda. {Sc} denota cualquier carácter que sea miembro de la categoría Símbolo Unicode, Moneda.
\s? Busca coincidencias con cero o un carácter de espacio en blanco.
(\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. Este es el primer grupo de captura.
\d+ Buscar coincidencias con uno o más dígitos decimales.
\.? Coincide con cero o una repetición de un punto (se usa como carácter separador decimal).
((?<=\.)\d+)? Si un punto es el carácter anterior, coincide con uno o varios dígitos decimales. Este patrón puede coincidir con cero o una vez.
(\d+\.?((?<=\.)\d+)?) Coincide con el patrón de uno o varios dígitos decimales seguidos de un punto opcional y dígitos decimales adicionales. Este es el segundo grupo de captura. La llamada al Replace(String, String) método reemplaza toda la coincidencia con el valor de este grupo capturado.
(?(1)|\s?\p{Sc})? Si el primer grupo capturado existe, coincida con una cadena vacía. De lo contrario, coincida con cero o un carácter de espacio en blanco seguido de un símbolo de moneda.

Comentarios

La búsqueda de coincidencias comienza al principio de la input cadena. La expresión regular es el patrón definido por el constructor para el objeto actual Regex .

El replacement parámetro especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones. Por ejemplo, el patrón a*${test}b de reemplazo inserta la cadena "a*" seguida de la subcadena que coincide con el test grupo de captura, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

Nota:

Las sustituciones son los únicos elementos del lenguaje de expresiones regulares que se reconocen en un patrón de reemplazo. Todos los demás elementos del lenguaje de expresiones regulares, incluidos los escapes de caracteres, solo se permiten en patrones de expresión regular y no se reconocen en patrones de reemplazo.

La RegexMatchTimeoutException excepción se produce 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. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el Regex objeto. Si no se define ningún tiempo de espera en la llamada del Regex constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Consulte también

Se aplica a

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.

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

Cadena en la que se va a buscar una coincidencia.

replacement
String

La cadena de reemplazo.

count
Int32

Número máximo de veces que puede producirse el reemplazo.

startat
Int32

Posición del carácter en la cadena de entrada donde comienza la búsqueda.

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. Si no se encuentran coincidencias del patrón de expresión regular en la instancia actual, el método devuelve la instancia sin modificar.

Excepciones

input o replacement es null.

startat es menor que cero o mayor que la longitud de input.

Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.

Ejemplos

En el ejemplo siguiente se duplican todos los espacios, pero la primera línea de una cadena. Define un patrón de expresión regular, ^.*$, que coincide con una línea de texto, llama al Match(String) método para que coincida con la primera línea de la cadena y usa las Match.Index propiedades y Match.Count para determinar la posición inicial de la segunda línea.

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.

Modelo Descripción
^ Coincide con el inicio de una línea. (Tenga en cuenta que el Regex objeto se creó mediante la RegexOptions.Multiline opción ; de lo contrario, esta clase de caracteres solo coincidiría con el principio de la cadena de entrada).
.* Coincidencia con cualquier carácter cero o más veces.
$ Coincide con el final de una línea. (Tenga en cuenta que el Regex objeto se creó mediante la RegexOptions.Multiline opción ; de lo contrario, esta clase de caracteres solo coincidiría con el principio de la cadena de entrada).

La cadena de reemplazo (vbCrLf + "$&" en Visual Basic, "\n$&" en C#) agrega una nueva línea antes de la cadena coincidente. Tenga en cuenta que \n en el ejemplo de C# se interpreta como el carácter de nueva línea por el compilador de C#; no representa un escape de caracteres de expresión regular.

Comentarios

La búsqueda de coincidencias comienza en la input cadena en la posición especificada por el startat parámetro . La expresión regular es el patrón definido por el constructor para el objeto actual Regex . Si count es negativo, los reemplazos continúan hasta el final de la cadena. Si count supera el número de coincidencias, se reemplazan todas las coincidencias.

Para obtener más información sobre startat, vea la sección Comentarios de Match(String, Int32).

El replacement parámetro especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones. Por ejemplo, el patrón a*${test}b de reemplazo inserta la cadena "a*" seguida de la subcadena que coincide con el test grupo de captura, si existe, seguida de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

Nota:

Las sustituciones son los únicos elementos del lenguaje de expresiones regulares que se reconocen en un patrón de reemplazo. Todos los demás elementos del lenguaje de expresiones regulares, incluidos los escapes de caracteres, solo se permiten en patrones de expresión regular y no se reconocen en patrones de reemplazo.

La RegexMatchTimeoutException excepción se produce 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. Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el Regex objeto. Si no se define ningún tiempo de espera en la llamada al Regex constructor o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

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 reemplazos en la cadena de entrada.

Consulte también

Se aplica a