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 escape | Descripción | Patrón | Coincidencia |
|---|---|---|---|
| \a | Coincide con el carácter de alerta (campana) \u0007. | \a | "\u0007" en "Warning!" + '\u0007' |
| \b | En 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" |
| \t | Coincide 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" |
| \r | Coincide 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." |
| \v | Coincide con el carácter de tabulación vertical \u000B. | [\v]{2,} | "\v\v\v" en "\v\v\v" |
| \f | Coincide con el carácter de avance de página \u000C. | [\f]{2,} | "\f\f\f" en "\f\f\f" |
| \n | Coincide 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." |
| \e | Coincide con el carácter de escape \u001B. | \e | "\x001B" en "\x001B" |
| \ nnn | Especifica 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 nn | Especifica 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 nnnn | Coincide 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 caracteres | Descripción | Patrón | Coincidencia |
|---|---|---|---|
| [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" |
| \w | Coincide 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" |
| \W | Coincide con cualquier carácter que no sea de palabra. Es el opuesto de \w. | \W | "#" en "Room#1" |
| \s | Coincide con cualquier carácter de espacio en blanco (espacio, tabulación, salto de línea, etc.). | \w\s | "D " en "ID A1.3" |
| \S | Coincide con cualquier carácter que no sea espacio en blanco. Es el opuesto de \s. | \s\S | " _" en "int __ctr" |
| \d | Coincide con cualquier dígito decimal. Equivalente a [0-9]. | \d | "4" en "4 = IV" |
| \D | Coincide con cualquier carácter que no sea un dígito decimal. Es el opuesto de \d. | \D | En "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ón | Descripción | Patrón | Coincidencia |
|---|---|---|---|
| ^ | 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" |
| \A | La 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-" |
| \Z | La coincidencia debe aparecer al final de la cadena o antes de un\nsalto de línea al final de la cadena. | -\d{3}\Z | el "-007" en "Bond-901-007" |
| \z | La coincidencia debe aparecer al final exacto de la cadena (final estricto, no se permite un \n al final). | -\d{3}\z | el "-333" en "-901-333" |
| \G | La 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) |
| \b | Coincide con un límite de palabra, es decir, la posición entre una palabra y un espacio. | er\b | Coincide con "er" en "never", pero no puede coincidir con "er" en "verb". |
| \B | Coincide con un no-límite de palabra. | er\B | Coincide 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ón | Descripción | Patrón | Coincidencia |
|---|---|---|---|
| ( subexpression ) | Captura la subexpresión coincidente y la asigna a un número ordinal que comienza en cero. | (\w)\1 | el "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+)\b | los "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+\b | los "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}\b | los "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\b | el "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.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:
| Cuantificador | Descripción | Patrón | Coincidencia |
|---|---|---|---|
| * | 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 inversa | Descripción | Patrón | Coincidencia |
|---|---|---|---|
| \ number | Referencia inversa. Coincide con el valor de la subexpresión numerada. | (\w)\1 | el "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 alternancia | Descripción | Patrón | Coincidencia |
|---|---|---|---|
| | | 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ácter | Descripción | Patrón | Patrón de reemplazo | Cadena de entrada | Cadena de resultado |
|---|---|---|---|---|---|
| $number | Reemplaza 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ón | Descripción | Ejemplo |
|---|---|---|
| (?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 |
|---|---|
| 1 | public 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. |
| 2 | public bool IsMatch(
string input,
int startat
)
Realiza la comprobación de coincidencia a partir de la posición inicial especificada en la cadena. |
| 3 | public 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. |
| 4 | public 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. |
| 5 | public 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. |
| 6 | public 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.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.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.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
// 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.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ón | Regex tradicional | GeneratedRegex (generador de código fuente) | Recomendación |
|---|---|---|---|
| Requisito de versión mínima | Compatible con todas las versiones de .NET Framework / .NET Core | .NET 7 y superiores | — |
| Momento de compilación | Análisis y compilación en tiempo de ejecución | En la fase de compilación (build time), el generador de código fuente de Roslyn genera el código | GeneratedRegex |
| Rendimiento de ejecución | Normal: más lento; con la opción Compiled: más rápido, pero con mayor sobrecarga de inicio | El más rápido, cercano al rendimiento de código escrito a mano y sin sobrecarga de inicio | GeneratedRegex |
| Uso de memoria | El modo Compiled genera código IL y usa más memoria | Genera código C# normal, más amigable con la memoria | GeneratedRegex |
| Compatibilidad con AOT | RegexOptions.Compiled no es compatible con AOT (compilación anticipada) | Totalmente compatible con Native AOT, adecuado para publicar aplicaciones independientes | GeneratedRegex |
| Legibilidad del código | La cadena del patrón se escribe directamente en el código; es más intuitivo | Se necesita definir métodos partial; la estructura del código es un poco más compleja | Regex tradicional (escenarios simples) |
| Patrón dinámico | Compatible; el patrón puede ser una variable en tiempo de ejecución | No compatible; el patrón debe ser una constante en tiempo de compilación | Regex tradicional (escenarios dinámicos) |
| Soporte de depuración | Normal | El código generado se puede ver y depurar directamente; es más transparente | GeneratedRegex |
| Escenarios de aplicación | Uso único, patrones dinámicos, proyectos .NET antiguos | Llamadas de alta frecuencia, sensibles al rendimiento, publicación AOT, proyectos .NET recientes | Depende 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 tradicional
new 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.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