Regex.Replace Método

Referencia

Definición

Espacio de nombres:: System.Text.RegularExpressions

Ensamblado:: System.Text.RegularExpressions.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

En una cadena de entrada especificada, reemplaza las cadenas que coinciden con un patrón de expresión regular por una cadena de reemplazo especificada.

Sobrecargas

Replace(String, String, String, RegexOptions)	En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena de reemplazo especificada. 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 especificada por una cadena de reemplazo especificada. Los parámetros adicionales especifican opciones que modifican la operación coincidente y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.
Replace(String, MatchEvaluator, 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 con una cadena devuelta por un delegado de MatchEvaluator.
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 de MatchEvaluator. Las opciones especificadas modifican la operación de coincidencia.
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 de MatchEvaluator. Los parámetros adicionales especifican opciones que modifican la operación coincidente y un intervalo de tiempo de espera si no se encuentra ninguna coincidencia.
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 con una cadena de reemplazo especificada.
Replace(String, String, String)	En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena de reemplazo especificada.
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 de MatchEvaluator.
Replace(String, String, Int32)	En una cadena 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)	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 de MatchEvaluator.
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, MatchEvaluator, Int32)	En una cadena 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 devuelta por un delegado de MatchEvaluator.

Replace(String, String, String, RegexOptions)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena de reemplazo especificada. 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 que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular que se va a coincidir.

replacement: String

Cadena de reemplazo.

options: RegexOptions

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

Devoluciones

String

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input, patterno replacement es null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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

Ejemplos

En el ejemplo siguiente se usa el método Replace(String, String, String, RegexOptions) para reemplazar los nombres de unidad y equipo local en una ruta de acceso UNC por una ruta de acceso del archivo local. La expresión regular usa la propiedad Environment.MachineName para incluir el nombre del equipo local y el método Environment.GetLogicalDrives 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 tabla siguiente se muestra cómo se interpreta el patrón de expresión regular.

Patrón	Descripción
`\\\\`	Coincide con dos caracteres consecutivos de barra diagonal inversa (`\`). 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 propiedad Environment.MachineName.
`(?:\.\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. No se captura la subexpresión coincidente.
`\\`	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 de reemplazo $1 reemplaza toda la coincidencia por la primera subexpresión capturada. Es decir, reemplaza el equipo UNC y el nombre de unidad por la letra de unidad.

Comentarios

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

El parámetro pattern 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 parámetro options, 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 parámetro replacement especifica la cadena que se va a reemplazar cada coincidencia en input. replacement puede constar de cualquier combinación de texto literal y sustituciones de . Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "a*" seguida de la subcadena que coincide con el grupo de captura test, 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 los patrones de reemplazo.

La excepción RegexMatchTimeoutException 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 método Object.ReferenceEquals 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 se agote el tiempo de espera del método. 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, String, RegexOptions, TimeSpan)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena de reemplazo especificada. Los parámetros adicionales especifican opciones que modifican la operación coincidente 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 que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular que se va a coincidir.

replacement: String

Cadena de reemplazo.

options: RegexOptions

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

matchTimeout: TimeSpan

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

Devoluciones

String

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input, patterno replacement es null.

ArgumentOutOfRangeException

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

-o-

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

RegexMatchTimeoutException

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

Ejemplos

En el ejemplo siguiente se usa el método Replace(String, String, String, RegexOptions, TimeSpan) para reemplazar los nombres de unidad y equipo local en una ruta de acceso UNC por una ruta de acceso del archivo local. La expresión regular usa la propiedad Environment.MachineName para incluir el nombre del equipo local y el método Environment.GetLogicalDrives para incluir los nombres de las unidades lógicas. Todas las comparaciones de cadenas de expresiones regulares 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 tabla siguiente se muestra cómo se interpreta el patrón de expresión regular.

Patrón	Descripción
`\\\\`	Coincide con dos caracteres consecutivos de barra diagonal inversa (`\`). 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 propiedad Environment.MachineName.
`(?:\.\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. No se captura la subexpresión coincidente.
`\\`	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 de reemplazo $1 reemplaza toda la coincidencia por la primera subexpresión capturada. Es decir, reemplaza el equipo UNC y el nombre de unidad por la letra de unidad.

Comentarios

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

Nota

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

Notas a los autores de las llamadas

Se recomienda establecer el parámetro matchTimeout 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

RegexOptions
sustituciones en expresiones regulares
elementos del lenguaje de expresiones regulares
retroceso en expresiones regulares
procedimientos recomendados de para expresiones regulares en .NET

Se aplica a

Replace(String, MatchEvaluator, Int32, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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 con una cadena devuelta por un delegado de MatchEvaluator.

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

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

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

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

Parámetros

input: String

Cadena que se va a buscar una coincidencia.

evaluator: MatchEvaluator

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 producirá el reemplazo.

startat: Int32

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

Devoluciones

String

Nueva cadena que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo tiene lugar de cada cadena coincidente. Si el patrón de expresión regular no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

ArgumentNullException

input o evaluator es null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

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

Comentarios

El método Regex.Replace(String, MatchEvaluator, Int32, Int32) 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 da como resultado algún procesamiento realizado en la cadena coincidente.
La cadena de reemplazo da como resultado el procesamiento condicional.

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

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 del objeto Regex actual.

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

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 excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación de reemplazo supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). 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 objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex 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.

Consulte también

MatchEvaluator
sustituciones en expresiones regulares
lenguaje de expresiones regulares: de referencia rápida

Se aplica a

Replace(String, String, MatchEvaluator, RegexOptions)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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 de 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 que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular que se va a coincidir.

evaluator: MatchEvaluator

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 para la coincidencia.

Devoluciones

String

Nueva cadena que es idéntica a la cadena de entrada, salvo que una cadena de reemplazo tiene lugar de cada cadena coincidente. Si pattern no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input, patterno evaluator es null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener 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 delegado de MatchEvaluator para llamar a un método denominado WordScramble que codifica las letras individuales de la palabra. Para ello, el método WordScramble 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 método Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) y la matriz ordenada se proporciona como argumento a un constructor de clase String. A continuación, el método WordScramble devuelve esta cadena recién creada. El patrón de expresión regular \w+ 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 método Replace(String, String, MatchEvaluator, RegexOptions) incluye la opción RegexOptions.IgnorePatternWhitespace para que el motor de expresiones regulares omita el comentario del patrón de expresión regular \w+ # Matches all the characters in a word..

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 método Regex.Replace(String, String, MatchEvaluator, RegexOptions) 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 da como resultado algún procesamiento realizado en la cadena coincidente.
La cadena de reemplazo da como resultado el procesamiento condicional.

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

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 parámetro options, 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.

Consulte también

Se aplica a

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

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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 de MatchEvaluator. Los parámetros adicionales especifican opciones que modifican la operación coincidente 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 que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular que se va a coincidir.

evaluator: MatchEvaluator

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 valores de enumeración que proporcionan opciones para la coincidencia.

matchTimeout: TimeSpan

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

Devoluciones

String

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input, patterno evaluator es null.

ArgumentOutOfRangeException

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

-o-

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

RegexMatchTimeoutException

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

Ejemplos

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 método Regex.Replace(String, String, MatchEvaluator, RegexOptions) 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 da como resultado algún procesamiento realizado en la cadena coincidente.
Si la cadena de reemplazo resulta del procesamiento condicional.

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

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.

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

Notas a los autores de las llamadas

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

RegexOptions
sustituciones en expresiones regulares
elementos del lenguaje de expresiones regulares
retroceso en expresiones regulares
procedimientos recomendados de para expresiones regulares en .NET

Se aplica a

Replace(String, String, Int32, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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 con 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 que se va a buscar una coincidencia.

replacement: String

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

String

Nueva cadena que es idéntica a la cadena de entrada, salvo que la cadena de reemplazo tiene lugar de cada cadena coincidente. Si el patrón de expresión regular no coincide con la instancia actual, el método devuelve la instancia actual sin cambios.

Excepciones

ArgumentNullException

input o replacement es null.

ArgumentOutOfRangeException

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

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener 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 método Match(String) para que coincida con la primera línea de la cadena y usa las propiedades Match.Index 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.

Patrón	Descripción
`^`	Coincide con el inicio de una línea. (Tenga en cuenta que el objeto Regex se creó una instancia mediante la opción RegexOptions.Multiline; de lo contrario, esta clase de caracteres solo coincidiría con el principio de la cadena de entrada).
`.*`	Coincide con cualquier carácter cero o más veces.
`$`	Coincide con el final de una línea. (Tenga en cuenta que el objeto Regex se creó una instancia mediante la opción RegexOptions.Multiline; 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 del compilador de C#; no representa un escape de caracteres de expresión regular.

Comentarios

La búsqueda de coincidencias se inicia en la cadena input en la posición especificada por el parámetro startat. La expresión regular es el patrón definido por el constructor del objeto Regex actual. 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).

Nota

Consulte también

sustituciones en expresiones regulares
lenguaje de expresiones regulares: de referencia rápida

Se aplica a

Replace(String, String, String)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

En una cadena de entrada especificada, reemplaza todas las cadenas que coinciden con una expresión regular especificada por una cadena de reemplazo especificada.

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 que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular que se va a coincidir.

replacement: String

Cadena de reemplazo.

Devoluciones

String

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input, patterno replacement es null.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener 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 método Replace(String, String, String) para reemplazar los nombres de unidad y equipo local en una ruta de acceso UNC por una ruta de acceso del archivo local. La expresión regular usa la propiedad Environment.MachineName para incluir el nombre del equipo local y el método Environment.GetLogicalDrives 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 tabla siguiente se muestra cómo se interpreta el patrón de expresión regular.

Patrón	Descripción
`\\\\`	Coincide con dos caracteres consecutivos de barra diagonal inversa (`\`). 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 propiedad Environment.MachineName.
`(?:\.\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. No se captura la subexpresión coincidente.
`\\`	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 de reemplazo $1 reemplaza toda la coincidencia por la primera subexpresión capturada. Es decir, reemplaza el equipo UNC y el nombre de unidad por la letra de unidad.

Comentarios

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

Nota

Notas a los autores de las llamadas

Consulte también

Se aplica a

Replace(String, String, MatchEvaluator)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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 de 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 que se va a buscar una coincidencia.

pattern: String

Patrón de expresión regular que se va a coincidir.

evaluator: MatchEvaluator

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

Devoluciones

String

Excepciones

ArgumentException

Error de análisis de expresiones regulares.

ArgumentNullException

input, patterno evaluator es null.

RegexMatchTimeoutException

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

Ejemplos

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 método Regex.Replace(String, String, MatchEvaluator) 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 da como resultado algún procesamiento realizado en la cadena coincidente.
La cadena de reemplazo da como resultado el procesamiento condicional.

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

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.

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 se agote el tiempo de espera del método. 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)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

En una cadena 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);

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 que se va a buscar una coincidencia.

replacement: String

Cadena de reemplazo.

count: Int32

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

Devoluciones

String

Excepciones

ArgumentNullException

input o replacement es null.

RegexMatchTimeoutException

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

Ejemplos

En el ejemplo siguiente se reemplazan las cinco primeras apariciones de caracteres duplicados por un solo carácter. El patrón de expresión regular (\w)\1 coincide con las apariciones consecutivas de un solo carácter y asigna la primera aparición al primer grupo de captura. El patrón de reemplazo $1 reemplaza toda la coincidencia por 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 cadena de input. La expresión regular es el patrón definido por el constructor para el objeto Regex actual. 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 parámetro replacement especifica la cadena que se va a reemplazar el primer count coincide en input. replacement puede constar de cualquier combinación de texto literal y sustituciones de . Por ejemplo, el patrón de reemplazo a*${test}b inserta la cadena "a*" seguida de la subcadena que coincide con el grupo de captura test, si existe, seguido de la cadena "b". El carácter * no se reconoce como metacaracter dentro de un patrón de reemplazo.

Nota

Consulte también

lenguaje de expresiones regulares: de referencia rápida
sustituciones en expresiones regulares

Se aplica a

Replace(String, MatchEvaluator)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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 de 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 que se va a buscar una coincidencia.

evaluator: MatchEvaluator

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

Devoluciones

String

Excepciones

ArgumentNullException

input o evaluator es null.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener 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, que 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 método Regex.Replace(String, MatchEvaluator) 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 da como resultado algún procesamiento realizado en la cadena coincidente.
La cadena de reemplazo da como resultado el procesamiento condicional.

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

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

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.

Consulte también

MatchEvaluator
sustituciones en expresiones regulares
lenguaje de expresiones regulares: de referencia rápida

Se aplica a

Replace(String, String)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

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 que se va a buscar una coincidencia.

replacement: String

Cadena de reemplazo.

Devoluciones

String

Excepciones

ArgumentNullException

input o replacement es null.

RegexMatchTimeoutException

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

Ejemplos

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?`	Coincide 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+`	Coincide con uno o varios dígitos decimales.
`\.?`	Coincide con cero o una aparició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 método Replace(String, String) reemplaza toda la coincidencia por 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, coincide 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 cadena de input. La expresión regular es el patrón definido por el constructor del objeto Regex actual.

Nota

Consulte también

lenguaje de expresiones regulares: de referencia rápida
sustituciones en expresiones regulares

Se aplica a

Replace(String, MatchEvaluator, Int32)

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

Source:: Regex.Replace.cs

En una cadena 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 devuelta por un delegado de 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 que se va a buscar una coincidencia.

evaluator: MatchEvaluator

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 producirá el reemplazo.

Devoluciones

String

Excepciones

ArgumentNullException

input o evaluator es null.

RegexMatchTimeoutException

Se agota el tiempo de espera. Para obtener 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 omitir deliberadamente la mitad de las palabras de una lista. Usa la expresión regular \w*(ie|ei)\w* para hacer coincidir palabras que incluyan los caracteres "ie" o "ei". Pasa la primera mitad de las palabras coincidentes al método ReverseLetter, que, a su vez, usa el método Replace(String, String, String, RegexOptions) 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.

Patrón	Descripción
`\w*`	Coincide con cero o más caracteres de palabra.
`(ie\|ei)`	Coincide con "ie" o "ei".
`\w*`	Coincide con cero o más caracteres de palabra.

El patrón de expresión regular ([ie])([ie]) en el método ReverseLetter coincide con el primer "i" o "e" en la 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. Los dos caracteres se invierten llamando al método Replace(String, String, String) con el patrón de reemplazo $2$1.

Comentarios

El método Regex.Replace(String, MatchEvaluator, Int32) 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 da como resultado algún procesamiento realizado en la cadena coincidente.
La cadena de reemplazo da como resultado el procesamiento condicional.

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

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

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.

Consulte también

MatchEvaluator
sustituciones en expresiones regulares
lenguaje de expresiones regulares: de referencia rápida

Se aplica a

Compartir a través de

Regex.Replace Método

Definición

Sobrecargas

Replace(String, String, String, RegexOptions)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

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

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Replace(String, MatchEvaluator, Int32, Int32)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

Replace(String, String, MatchEvaluator, RegexOptions)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

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

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Replace(String, String, Int32, Int32)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Replace(String, String, String)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Replace(String, String, MatchEvaluator)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Notas a los autores de las llamadas

Consulte también

Se aplica a

Replace(String, String, Int32)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a