Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Regex.Replace (String, String, String)

 

Publicado: noviembre de 2016

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

Espacio de nombres:   System.Text.RegularExpressions
Ensamblado:  System (en System.dll)

public static string Replace(
	string input,
	string pattern,
	string replacement
)

Parámetros

input
Type: System.String

Cadena en la que se va a buscar una coincidencia.

pattern
Type: System.String

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

replacement
Type: System.String

La cadena de reemplazo.

Valor devuelto

Type: System.String

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 en la instancia actual, el método devuelve la instancia actual sin modificar.

Exception Condition
ArgumentException

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

ArgumentNullException

El valor de input, pattern o replacement es null.

RegexMatchTimeoutException

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

Estático Replace métodos son equivalentes a construir un Regex de objetos con el patrón de expresión regular especificado y llamar al método de instancia Replace.

El pattern parámetro consta de elementos de 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 Framework y Lenguaje de expresiones regulares - Referencia rápida. Comienza la búsqueda de coincidencias 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 de reemplazo a*${test}b inserta la cadena "un *" seguida de la subcadena que coincide con el test captura de grupo, si los hay, seguida por la cadena "b". El * caracteres no se reconocen como un metacarácter dentro de un modelo de reemplazo.

System_CAPS_noteNota

Las sustituciones son los elementos del lenguaje de expresión regular solo se reconocen en un modelo de reemplazo. Todos los demás elementos de lenguaje de expresiones regulares, incluidos escapes de carácter, se permiten en sólo los patrones de expresiones regulares y no se reconocen en modelos de reemplazo.

El 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 la que se llama al método. Si ningún tiempo de espera se define en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, se inicia 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 ningún reemplazo para la cadena de entrada.

Notas para llamadores:

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

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

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "whitespace.";
      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   whitespace.
//       Replacement String: This is text with far too much whitespace.

En el ejemplo siguiente se usa el Replace(String, String, String) método para reemplazar los nombres de equipo y la unidad locales en una ruta UNC con una ruta de acceso de archivo local. La expresión regular usa el Environment.MachineName 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 "Miequipo" con 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

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

"\\\\(?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

\\\\

Inversas consecutivas de coincidencia dos (\) caracteres. Dado el carácter de barra diagonal inversa se interpreta como el carácter de escape, cada barra diagonal inversa debe ser de escape con otra barra diagonal inversa.

(?i:" + Environment.MachineName + ")

Realizar una coincidencia entre mayúsculas y minúsculas de la cadena devuelta por la Environment.MachineName propiedad.

(?:\.\w+)*

Coincide con el punto (.) carácter seguido de uno o más caracteres alfabéticos. Esta coincidencia puede producirse cero o más veces. No se captura la subexpresión coincidente.

\\

Coincide con una barra diagonal inversa (\) caracteres.

((?i:[" + driveNames + "]))

Realizar a una coincidencia entre mayúsculas y minúsculas de la clase de caracteres que se compone de las letras de unidad individuales. Esta coincidencia es la primera subexpresión capturada.

\$

Coincide con el signo de dólar ($) caracteres.

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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: