C# Expresiones regulares

Expresiones regularesEs una fórmula de búsqueda que se utiliza para describir y coincidir con patrones de texto. En términos simples, puedes entenderlo como un lenguaje especial de comodines que se usa para encontrar, validar o reemplazar contenido dentro de cadenas de texto con precisión.

Por ejemplo, determinar si la entrada del usuario es una dirección de correo electrónico o un número de teléfono válido, o extraer todas las fechas de un texto: estos son casos de uso típicos de las expresiones regulares.

El framework .NET incorpora un motor de expresiones regulares completo, y el soporte se proporciona a través delSystem.Text.RegularExpressionsespacio de nombres.

Un patrón de expresión regular se compone de uno o más caracteres, operadores y estructuras que juntos describen las reglas de texto a coincidir.

Si aún no entiendes las expresiones regulares, puedes leer nuestroExpresiones regulares - Tutorial。

Definición de expresiones regulares

Las expresiones regulares se componen de los siguientes tipos de bloques de construcción, cada uno responsable de una función de coincidencia diferente:

  • Escapado de caracteres: hace que los caracteres especiales sean tratados como caracteres comunes (por ejemplo,\.coincide con un punto real)
  • Clases de caracteres: coincide con "una clase" de caracteres (por ejemplo,\dcoincide con cualquier dígito)
  • Anclas: especifican la "posición" donde ocurre la coincidencia (por ejemplo,^indica el inicio de la línea)
  • Construcciones de agrupación: agrupan subpatrones para facilitar la captura o referencia
  • Cuantificadores: controlan el número de veces que aparece un elemento (por ejemplo,+indica una o más veces)
  • Construcciones de referencia inversa: referencian contenido previamente capturado para volver a coincidir
  • Construcciones de alternancia: implementan la lógica "o" (por ejemplo,cat|dog)
  • Reemplazo: referencian el contenido capturado en operaciones de reemplazo
  • Construcciones varias: funciones auxiliares como opciones en línea, comentarios, etc.

Escapado de caracteres

En las expresiones regulares, el carácter de barra invertida (\) tiene dos funciones: primero, convierte elcarácter común que le sigue en un significado especial(por ejemplo,\nindica un salto de línea), y segundo, conviertecaracteres especiales en caracteres literales(por ejemplo,\.coincide con un punto real en lugar de "cualquier carácter").

Error común para principiantes: en una cadena de C#,\en sí mismo también es un carácter de escape, por lo que en la expresión regular se escribe\d, en la cadena de C# se debe escribir"\\d", o usar una cadena textual (verbatim string)@"\d"(recomendado).

La siguiente tabla enumera los caracteres de escape comunes:

Carácter de escapeDescripciónPatrónCoincidencia
\aCoincide con el carácter de alerta (campana) \u0007.\a"\u0007" en "Warning!" + '\u0007'
\bEn una clase de caracteres, coincide con la tecla de retroceso \u0008. (Nota: fuera de una clase de caracteres, \b indica un límite de palabra; ver la sección "Anclas").[\b]{3,}"\b\b\b\b" en "\b\b\b\b"
\tCoincide con el carácter de tabulación \u0009. Se usa a menudo para coincidir con texto separado por tabulaciones.(\w+)\t"Name\t" y "Addr\t" en "Name\tAddr\t"
\rCoincide con el retorno de carro \u000D. (\r no es equivalente al salto de línea \n. El salto de línea en Windows suele ser \r\n).\r\n(\w+)"\r\nHello" en "\r\nHello\nWorld."
\vCoincide con el carácter de tabulación vertical \u000B.[\v]{2,}"\v\v\v" en "\v\v\v"
\fCoincide con el carácter de avance de página \u000C.[\f]{2,}"\f\f\f" en "\f\f\f"
\nCoincide con el carácter de salto de línea \u000A. En sistemas Unix/Linux, el final de línea suele ser solo \n.\r\n(\w+)"\r\nHello" en "\r\nHello\nWorld."
\eCoincide con el carácter de escape \u001B.\e"\x001B" en "\x001B"
\ nnnEspecifica un carácter en representación octal (nnn consta de dos a tres dígitos).\w\040\w"a b" y "c d" en "a bc d"
\x nnEspecifica un carácter en representación hexadecimal (nn consta exactamente de dos dígitos).\w\x20\w"a b" y "c d" en "a bc d"
\c X \c x Coincide con el carácter de control ASCII especificado por X o x, donde X o x es la letra del carácter de control.\cC"\x0003" (Ctrl-C) en "\x0003"
\u nnnnCoincide con un carácter Unicode en representación hexadecimal (cuatro dígitos representados por nnnn).\w\u0020\w"a b" y "c d" en "a bc d"
\Cuando va seguido de un carácter de escape no reconocido, coincide con ese carácter.\d+[\+-x\*]\d+\d+[\+-x\*\d+"2+2" y "3*9" en "(2+2) * 3*9"

Clases de caracteres

Las clases de caracteres se utilizan para coincidir, de entre una 'clase' de caracteres,con cualquiera de ellos.Por ejemplo,[aeiou]coincide con cualquier vocal,\dcoincide con cualquier dígito. Esta es una de las funciones básicas más utilizadas en las expresiones regulares.

La siguiente tabla enumera las clases de caracteres:

Clase de caracteresDescripciónPatrónCoincidencia
[character_group]Coincide con cualquier carácter individual en character_group. De forma predeterminada, la coincidencia distingue entre mayúsculas y minúsculas.[mn]"m" en "mat", "m" y "n" en "moon"
[^character_group]Negación: coincide con cualquier carácter individual que no esté en character_group. De forma predeterminada, los caracteres en character_group distinguen entre mayúsculas y minúsculas.[^aei]"v" y "l" en "avail"
[ first - last ]Rango de caracteres: coincide con cualquier carácter individual en el rango de first a last.[b-d][b-d]irds puede coincidir con Birds, Cirds, Dirds
.Comodín: coincide con cualquier carácter individual excepto \n.
Para coincidir con el carácter de punto literal (. o \u002E), debe anteponer el carácter de escape (\.).
a.e"ave" en "have", "ate" en "mate"
\p{ name }ynameCoincide con cualquier carácter individual en la categoría general Unicode especificada o bloque con nombre.\p{Lu} "C" y "L" en "City Lights"
\P{ name }con cualquier carácter que no esté ennamela categoría general Unicode o bloque con nombre especificado.\P{Lu}"i", "t" y "y" en "City"
\wCoincide con cualquier carácter de palabra (letra, dígito, guion bajo). Equivalente a [a-zA-Z0-9_] (en el rango ASCII).\w"R", "o", "m" y "1" en "Room#1"
\WCoincide con cualquier carácter que no sea de palabra. Es el opuesto de \w.\W"#" en "Room#1"
\sCoincide con cualquier carácter de espacio en blanco (espacio, tabulación, salto de línea, etc.).\w\s"D " en "ID A1.3"
\SCoincide con cualquier carácter que no sea espacio en blanco. Es el opuesto de \s.\s\S" _" en "int __ctr"
\dCoincide con cualquier dígito decimal. Equivalente a [0-9].\d"4" en "4 = IV"
\DCoincide con cualquier carácter que no sea un dígito decimal. Es el opuesto de \d.\DEn "4 = IV", los " ", "=", " ", "I" y "V"

Anclas

Las anclas (también llamadas "anclajes") no coinciden con ningún carácter concreto, sino con una determinadaposición.Son de "ancho cero", no consumen ningún carácter, solo afirman que la posición actual cumple cierta condición.

Por ejemplo^\d{3}(9)"\brepresenta "el límite entre un carácter de palabra y uno que no lo es".

La siguiente tabla enumera las anclas:

AserciónDescripciónPatrónCoincidencia
^La coincidencia debe comenzar al inicio de la cadena o de una línea.^\d{3}el "567" en "567-777-"
$La coincidencia debe aparecer al final de la cadena o antes de un\nsalto de línea al final de la línea o de la cadena.-\d{4}$el "-2012" en "8-12-2012"
\ALa coincidencia debe aparecer al inicio de la cadena (no se ve afectado por el modo multilínea; siempre es el inicio de toda la cadena).\A\w{4}el "Code" en "Code-007-"
\ZLa coincidencia debe aparecer al final de la cadena o antes de un\nsalto de línea al final de la cadena.-\d{3}\Zel "-007" en "Bond-901-007"
\zLa coincidencia debe aparecer al final exacto de la cadena (final estricto, no se permite un \n al final).-\d{3}\zel "-333" en "-901-333"
\GLa coincidencia debe aparecer donde terminó la coincidencia anterior. Se usa a menudo en escenarios de coincidencias consecutivas.\G\(\d\)los "(1)", "(3)" y "(5)" en "(1)(3)(5)
\bCoincide con un límite de palabra, es decir, la posición entre una palabra y un espacio.er\bCoincide con "er" en "never", pero no puede coincidir con "er" en "verb".
\BCoincide con un no-límite de palabra.er\BCoincide con "er" en "verb", pero no puede coincidir con "er" en "never".

Construcciones de agrupación

Las construcciones de agrupación utilizan paréntesis( )para encerrar una parte de la expresión regular y formar una subexpresión. La agrupación tiene dos usos principales:

  • Captura: "guardar" la subcadena coincidente para poder extraerla o referenciarla posteriormente en un reemplazo.
  • Limitación de ámbito: hacer que los cuantificadores o las construcciones alternativas actúen solo sobre la subexpresión dentro del grupo.

Esta parte es algo difícil de entender; puedes leerExpresiones regulares - Alternancia 、Aserciones de anticipación (lookahead) y de retroceso (lookbehind) en expresiones regularespara ayudarte a comprenderlo.

La siguiente tabla enumera las construcciones de agrupación:

Construcción de agrupaciónDescripciónPatrónCoincidencia
( subexpression )Captura la subexpresión coincidente y la asigna a un número ordinal que comienza en cero.(\w)\1el "ee" en "deep"
(?< name >subexpression)Captura la subexpresión coincidente en un grupo con nombre. Los grupos con nombre son más legibles que la numeración numérica; se recomienda usarlos en expresiones regulares complejas.(?< double>\w)\k< double>el "ee" en "deep"
(?< name1 -name2 >subexpression)Define la definición de grupo equilibrado. Se usa para coincidir con estructuras anidadas (como pares de paréntesis); es una característica avanzada.(((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$el "((1-3)*(3-1))" en "3+2^((1-3)*(3-1))"
(?: subexpression)Define un grupo de no captura. Se usa cuando solo se necesita agrupar (limitar el ámbito) sin guardar el contenido coincidente; el rendimiento es ligeramente mejor que el de un grupo de captura.Write(?:Line)?el "WriteLine" en "Console.WriteLine()"
(?imnsx-imnsx:subexpression)Aplica o desactivasubexpressionlas opciones especificadas en el patrón.A\d{2}(?i:\w+)\blos "A12xl" y "A12XL" en "A12xl A12XL a12xl"
(?= subexpression)Aserción de anticipación positiva de ancho cero (lookahead). Coincide con la posición donde la subexpresión sigue inmediatamente, pero no consume caracteres.\w+(?=\.)los "is", "ran" y "out" en "He is. The dog ran. The sun is out."
(?! subexpression)Aserción de anticipación negativa de ancho cero. Coincide con la posición donde no sigue la subexpresión.\b(?!un)\w+\blos "sure" y "used" en "unsure sure unity used"
(?<=subexpression)Aserción de retroceso positiva de ancho cero (lookbehind). Coincide con la posición donde la subexpresión precede inmediatamente.(?<=19)\d{2}\blos "99", "50" y "05" en "1851 1999 1950 1905 2003"
(?<! subexpression)Aserción de retroceso negativa de ancho cero. Coincide con la posición donde la subexpresión no precede.(?<!wo)man\bel "man" en "Hi woman Hi man"
(?> subexpression)Subexpresión sin retroceso (grupo atómico). Una vez que coincide, no se permite el retroceso; puede mejorar el rendimiento en ciertos escenarios.[13579](?>A+B+)los "1ABB", "3ABB" y "5AB" en "1ABB 3ABBC 5AB 5AC"

Ejemplo

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1851 1999 1950 1905 2003";
      string pattern = @"(?<=19)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}


Cuantificadores

Los cuantificadores especifican que el elemento anterior (carácter, clase de carácter o grupo) debe aparecercuántas vecespara que la coincidencia sea exitosa.

Los cuantificadores son por defectocodiciosos, es decir, coinciden con tantos caracteres como sea posible. Al agregar un ? después del cuantificador?se puede convertir enperezoso (no codicioso)modo, es decir, coincidir con la menor cantidad de caracteres posible. Los principiantes pueden dominar primero*、+、?、{n}estos cuatro cuantificadores básicos.

La siguiente tabla enumera los cuantificadores:

CuantificadorDescripciónPatrónCoincidencia
*Coincide con el elemento anterior cero o más veces. (Cero veces también cuenta como coincidencia.)\d*\.\d".0"、 "19.9"、 "219.9"
+Coincide con el elemento anterior una o más veces. (Al menos una vez.)"be+""bee" en "been", "be" en "bent"
?Coincide con el elemento anterior cero o una vez. (Es decir, el elemento es opcional.)"rai?n""ran"、 "rain"
{ n }Coincide con el elemento anterior exactamente n veces.",\d{3}"",043" en "1,043.6"; ",876", ",543" y ",210" en "9,876,543,210"
{ n ,}Coincide con el elemento anterior al menos n veces."\d{2,}""166"、 "29"、 "1930"
{ n , m }Coincide con el elemento anterior al menos n veces, pero no más de m veces."\d{3,5}""166", "17668", "19302" en "193024"
*?Coincide con el elemento anterior cero o más veces, pero con la menor cantidad posible (modo perezoso).\d*?\.\d".0"、 "19.9"、 "219.9"
+?Coincide con el elemento anterior una o más veces, pero con la menor cantidad posible (modo perezoso)."be+?""be" en "been", "be" en "bent"
??Coincide con el elemento anterior cero o una vez, pero con la menor cantidad posible (modo perezoso)."rai??n""ran"、 "rain"
{ n }?Coincide con el elemento anterior exactamente n veces.",\d{3}?"",043" en "1,043.6"; ",876", ",543" y ",210" en "9,876,543,210"
{ n ,}?Coincide con el elemento anterior al menos n veces, pero con la menor cantidad posible."\d{2,}?""166", "29" y "1930"
{ n , m }?Coincide con el elemento anterior entre n y m veces, pero con la menor cantidad posible."\d{3,5}?""166", "17668", "193" y "024" en "193024"

Construcciones de referencia inversa

Las referencias inversas permiten, dentro de la misma expresión regular, referenciarel contenido de un grupo previamente capturadopara volver a coincidir. Por ejemplo, usando(\w)\1se pueden encontrar caracteres repetidos consecutivos como "ee", "ll".

La siguiente tabla enumera las construcciones de referencias inversas:

Construcción de referencia inversaDescripciónPatrónCoincidencia
\ numberReferencia inversa. Coincide con el valor de la subexpresión numerada.(\w)\1el "ee" en "seek"
\k< name >Referencia inversa con nombre. Coincide con el valor de la expresión con nombre. Es más legible que la referencia numérica; se recomienda usarla.(?< char>\w)\k< char>el "ee" en "seek"

Construcciones de alternancia

Las construcciones de alternancia utilizan la barra vertical|para implementar la lógica "o", permitiendo que la expresión regular coincida con cualquiera de varios patrones candidatos. Es similar al operador||en los lenguajes de programación.

La siguiente tabla enumera las construcciones de alternancia:

Construcción de alternanciaDescripciónPatrónCoincidencia
|Coincide con cualquiera de los elementos separados por el carácter de barra vertical (|).th(e|is|at)los "the" y "this" en "this is the day. "
(?( expression )yes | no )Si el patrón de la expresión regular coincide con lo especificado por expression, entonces coincideyes; de lo contrario, coincide con la parte opcionalno. expression se interpreta como una aserción de ancho cero.(?(A)A\d{2}\b|\b\d{3}\b)En "A10 C103 910", los "A10" y "910"
(?( name )yes | no )Si name o un grupo de captura con nombre o numerado tiene una coincidencia, entonces coincideyes; de lo contrario, coincide con el opcionalno。(?< quoted>")?(?(quoted).+?"|\S+\s)En "Dogs.jpg "Yiska playing.jpg"", Dogs.jpg y "Yiska playing.jpg"

Reemplazo

La sintaxis de reemplazo se usa paraRegex.Replace()del métodola cadena de patrón de reemplazo, se puede, mediante$agregar un número o un nombre para hacer referencia al contenido de los grupos capturados previamente, logrando una reorganización flexible del texto.

La siguiente tabla enumera los caracteres utilizados para el reemplazo:

CarácterDescripciónPatrónPatrón de reemplazoCadena de entradaCadena de resultado
$numberReemplaza por gruponumberla subcadena coincidente.\b(\w+)(\s)(\w+)\b$3$2$1"one two""two one"
${name}Reemplaza por grupo con nombrenamela subcadena coincidente.\b(?< word1>\w+)(\s)(?< word2>\w+)\b${word2} ${word1}"one two""two one"
$$Reemplaza el carácter "$".\b(\d+)\s?USD$$$1"103 USD""$103"
$&Reemplaza con una copia de la coincidencia completa.(\$*(\d*(\.+\d+)?){1})**$&"$1.30""**$1.30"
$`Reemplaza todo el texto de la cadena de entrada anterior a la coincidencia.B+$`"AABBCC""AAAACC"
$'Reemplaza todo el texto de la cadena de entrada posterior a la coincidencia.B+$'"AABBCC""AACCCC"
$+Reemplaza el último grupo capturado.B+(C+)$+"AABBCCDD"AACCDD
$_Reemplaza toda la cadena de entrada.B+$_"AABBCC""AAAABBCCCC"

Construcciones varias

La siguiente tabla enumera varias construcciones misceláneas:

ConstrucciónDescripciónEjemplo
(?imnsx-imnsx)Establece o desactiva opciones como no distinguir mayúsculas y minúsculas en medio del patrón.\bA(?i)b\w+\b coincide con "ABA" y "Able" en "ABA Able Act"
(?#comentario)Comentario en línea. Dicho comentario termina en el primer paréntesis de cierre.\bA(?#coincide con palabras que comienzan con A)\w+\b
# [Fin de línea]Este comentario comienza con un # sin escapar y continúa hasta el final de la línea.(?x)\bA\w+\b#Coincide con palabras que comienzan con A

Clase Regex

La clase Regex es la clase central para el uso de expresiones regulares en .NET y se encuentra en elSystem.Text.RegularExpressionsespacio de nombres. Antes de usarla, se debe agregar en la parte superior del archivo:

using System.Text.RegularExpressions;

La siguiente tabla enumera algunos métodos de uso común en la clase Regex:

N.ºMétodo y descripción
1public bool IsMatch( string input )
Determina si la cadena de entrada contiene contenido que coincida con el patrón de la expresión regular. A menudo se usa en la validación de formularios, como verificar formatos de teléfono móvil o correo electrónico.
2public bool IsMatch( string input, int startat )
Realiza la comprobación de coincidencia a partir de la posición inicial especificada en la cadena.
3public static bool IsMatch( string input, string pattern )
Método estático; no es necesario crear primero un objeto Regex, se pasa directamente la cadena de patrón para realizar la comprobación. Es adecuado para escenarios de un solo uso.
4public MatchCollection Matches( string input )
Busca todas las coincidencias en la cadena de entrada y devuelve una colección MatchCollection, que se puede recorrer con foreach para cada resultado coincidente.
5public string Replace( string input, string replacement )
Reemplaza todo el contenido de la cadena de entrada que coincida con el patrón de expresión regular por la cadena especificada.
6public string[] Split( string input )
Divide la cadena de entrada en una matriz de subcadenas según los delimitadores definidos en el patrón de la expresión regular. Es más flexible que string.Split() y admite reglas de separación complejas.

Para ver la lista completa de propiedades de la clase Regex, consulte la documentación de C# de Microsoft.

Ejemplo 1

El siguiente ejemplo coincide con palabras que comienzan con 'S':

Análisis:\bes un límite de palabra,Scoincide con la letra mayúscula S,\S*coincide con cero o más caracteres que no son espacios en blanco; en conjunto, forman "una palabra completa que comienza con S".

Ejemplo

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "A Thousand Splendid Suns";

         Console.WriteLine("Matching words that start with 'S': ");
         showMatch(str, @"\bS\S*");
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Matching words that start with 'S':
The Expression: \bS\S*
Splendid
Suns

Ejemplo 2

El siguiente ejemplo coincide con palabras que comienzan con 'm' y terminan con 'e':

Análisis:\bmcoincide con palabras que comienzan con m,\S*coincide con cualquier carácter intermedio que no sea un espacio en blanco,e\bexige que termine con e y que después haya un límite de palabra; en conjunto, busca todas las palabras que comienzan con m y terminan con e.

Ejemplo

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "make maze and manage to measure it";

         Console.WriteLine("Matching words start with 'm' and ends with 'e':");
         showMatch(str, @"\bm\S*e\b");
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
make
maze
manage
measure

Ejemplo 3

El siguiente ejemplo reemplaza los espacios superfluos:

Análisis:\\s+Coincide con uno o más caracteres de espacio en blanco consecutivos (espacios, tabulaciones, etc.), los reemplaza todos por un solo espacio y así consolida el espacio en blanco redundante.

Ejemplo

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         string input = "Hello   World   ";
         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);    
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Original String: Hello   World   
Replacement String: Hello World   

GeneratedRegex: optimización del generador de código fuente (.NET 7+)

A partir de .NET 7, C# introdujo[GeneratedRegex]el atributo (generador de código fuente), que es una mejora importante frente a laRegexclase Regex, especialmente parasensibles al rendimientooy de uso repetidoescenarios de expresiones regulares.

Problemas del método tradicional

Al usar el Regex tradicional,new Regex(pattern)el análisis y la compilación de la expresión regular se realizan entiempo de ejecución, cada creación tiene sobrecarga. Aunque se puede usarRegexOptions.Compiledpara aumentar la velocidad de ejecución, la compilación sigue realizándose en tiempo de ejecución y aumenta el tiempo de inicio y el uso de memoria.

Método tradicional

using System.Text.RegularExpressions;

// Método 1: reanalizar en cada llamada (el más lento)
bool isMatch = Regex.IsMatch(input, @"\d{4}-\d{2}-\d{2}");

// Método 2: campo estático + Compiled (optimización común)
private static readonly Regex DateRegex = new Regex(@"\d{4}-\d{2}-\d{2}", RegexOptions.Compiled);

Uso de GeneratedRegex

Al usar[GeneratedRegex]el atributo, el compiladoren la fase de compilacióngenera directamente la expresión regular como código C# eficiente, sin necesidad de análisis ni compilación en tiempo de ejecución.

Requisitos: se necesita .NET 7 o superior, y el método debe ser unpartialmétodo, y la clase que lo contiene también debe ser unapartialclase.

Uso básico de GeneratedRegex

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   // La clase debe declararse como partial
   partial class Program
   {
      // Usar el atributo [GeneratedRegex]; el compilador genera automáticamente la implementación
      [GeneratedRegex(@"\d{4}-\d{2}-\d{2}")]
      private static partial Regex DateRegex();

      // También se pueden añadir opciones, por ejemplo, ignorar mayúsculas y minúsculas
      [GeneratedRegex(@"\bS\S*", RegexOptions.IgnoreCase)]
      private static partial Regex StartsWithSRegex();

      static void Main(string[] args)
      {
         string input = "Today is 2024-06-18, next event: 2025-01-01";

         // Úsalo como un método normal; devuelve una instancia de Regex
         foreach (Match m in DateRegex().Matches(input))
         {
            Console.WriteLine("Fecha encontrada: " + m.Value);
         }

         // Verificar si coincide
         Console.WriteLine(StartsWithSRegex().IsMatch("Splendid")); // True
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

找到日期:2024-06-18
找到日期:2025-01-01
True

Comparación entre GeneratedRegex y Regex tradicional

La siguiente tabla compara ambos métodos desde múltiples dimensiones para ayudarte a elegir el uso adecuado:

Dimensión de comparaciónRegex tradicionalGeneratedRegex (generador de código fuente)Recomendación
Requisito de versión mínimaCompatible con todas las versiones de .NET Framework / .NET Core.NET 7 y superiores—
Momento de compilaciónAnálisis y compilación en tiempo de ejecuciónEn la fase de compilación (build time), el generador de código fuente de Roslyn genera el códigoGeneratedRegex
Rendimiento de ejecuciónNormal: más lento; con la opción Compiled: más rápido, pero con mayor sobrecarga de inicioEl más rápido, cercano al rendimiento de código escrito a mano y sin sobrecarga de inicioGeneratedRegex
Uso de memoriaEl modo Compiled genera código IL y usa más memoriaGenera código C# normal, más amigable con la memoriaGeneratedRegex
Compatibilidad con AOTRegexOptions.Compiled no es compatible con AOT (compilación anticipada)Totalmente compatible con Native AOT, adecuado para publicar aplicaciones independientesGeneratedRegex
Legibilidad del códigoLa cadena del patrón se escribe directamente en el código; es más intuitivoSe necesita definir métodos partial; la estructura del código es un poco más complejaRegex tradicional (escenarios simples)
Patrón dinámicoCompatible; el patrón puede ser una variable en tiempo de ejecuciónNo compatible; el patrón debe ser una constante en tiempo de compilaciónRegex tradicional (escenarios dinámicos)
Soporte de depuraciónNormalEl código generado se puede ver y depurar directamente; es más transparenteGeneratedRegex
Escenarios de aplicaciónUso único, patrones dinámicos, proyectos .NET antiguosLlamadas de alta frecuencia, sensibles al rendimiento, publicación AOT, proyectos .NET recientesDepende del escenario

Recomendaciones de uso

  • Si usas.NET 7+y el patrón de la expresión regular es fijo,prioriza el uso de[GeneratedRegex]。
  • Si el patrón de expresión regular necesita construirse dinámicamente en tiempo de ejecución (como generarlo a partir de la entrada del usuario), solo se puede usar el método tradicionalnew Regex(pattern)。
  • Si el proyecto necesita soportarNative AOTla publicación (como el modo AOT de .NET 8), asegúrate de usar[GeneratedRegex]en lugar deRegexOptions.Compiled。
  • Para principiantes, pueden aprender y practicar primero con el método tradicional, y después de comprender los principios de las expresiones regulares, migrar gradualmente a proyectos reales.[GeneratedRegex]。

Ejemplo: Validar formato de correo electrónico con GeneratedRegex

using System;
using System.Text.RegularExpressions;

partial class EmailValidator
{
   // Definir la expresión regular de validación de correo, ignorando mayúsculas y minúsculas
   [GeneratedRegex(@"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$", RegexOptions.IgnoreCase)]
   private static partial Regex EmailRegex();

   public static bool IsValidEmail(string email)
   {
      return EmailRegex().IsMatch(email);
   }

   static void Main(string[] args)
   {
      string[] emails = { "user@example.com", "bad-email", "hello@world.org", "missing@dot" };
      foreach (var email in emails)
      {
         Console.WriteLine($"{email}: {(IsValidEmail(email) ? "Válido" : "Inválido")}");
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

user@example.com: 有效
bad-email: 无效
hello@world.org: 有效
missing@dot: 无效
Otras extensiones