Ejemplo: Buscar etiquetas NavigateURL

En el ejemplo siguiente se busca una cadena de entrada y se imprimen todos los valores NavigateURL="…" y sus posiciones en la cadena. Esta operación se realiza creando un objeto Regex compilado y utilizando, a continuación, un objeto Match para recorrer en iteración todas las coincidencias de la cadena.

En este ejemplo, el metacarácter \s coincide con cualquier carácter de espacio, y \S coincide con cualquier carácter que no sea un espacio.

    Sub DumpNavigateURLs(inputString As String)
        Dim r As Regex
        Dim m As Match
    
        r = New Regex("NavigateURL\s*=\s*(?:""(?<1>[^""]*)""|(?<1>\S+))", _
            RegexOptions.IgnoreCase Or RegexOptions.Compiled)
    
        m = r.Match(inputString)
        While m.Success
            Console.WriteLine("Found NavigateURL " & m.Groups(1).Value _
                & " at " & m.Groups(1).Index.ToString())
            m = m.NextMatch()
        End While
    End Sub

    void DumpNavigateURLs(String inputString) 
    {
        Regex r;
        Match m;

        r = new Regex("NavigateURL\\s*=\\s*(?:\"(?<1>[^\"]*)\"|(?<1>\\S+))",
            RegexOptions.IgnoreCase|RegexOptions.Compiled);
        for (m = r.Match(inputString); m.Success; m = m.NextMatch()) 
        {
            Console.WriteLine("Found NavigateURL " + m.Groups[1] + " at " 
                + m.Groups[1].Index);
        }
    }

Patrón compilado

Antes de iniciar el bucle de búsqueda de la cadena, este ejemplo de código crea un objeto Regex para almacenar el patrón compilado. Puesto que el análisis, la optimización y la compilación de una expresión regular llevan algún tiempo, estas tareas se realizan fuera del bucle para evitar que se repitan.

Las instancias de la clase Regex son inmutables; cada una se corresponde con un único patrón y son independientes. Esto permite que varias funciones, o incluso varios subprocesos, compartan una única instancia de Regex.

Clase de resultados Match

Los resultados de una búsqueda se almacenan en la clase Match, que proporciona acceso a todas las subcadenas extraídas por la búsqueda. Esta clase recuerda también la cadena buscada y la expresión regular utilizada, para poder utilizarlas en otra búsqueda, que comenzará donde terminó la última.

Capturas con nombre explícito

En las expresiones regulares tradicionales, los paréntesis de captura se numeran automáticamente de forma secuencial. Esto implica dos problemas. En primer lugar, si se modifica una expresión regular al insertar o quitar un grupo de paréntesis, todo el código que hace referencia a las capturas numeradas debe reescribirse para que la nueva numeración quede reflejada. En segundo lugar, dado que a menudo se utilizan grupos de paréntesis distintos con el fin de proporcionar expresiones alternativas para la búsqueda de una coincidencia aceptable, puede resultar difícil determinar cual de las dos expresiones ha devuelto en realidad un resultado.

Para solucionar estos problemas, Regex permite utilizar la sintaxis (?<name>…) para capturar una coincidencia en una ranura especificada (puede asignarle un nombre a la ranura utilizando una cadena o un entero, aunque resulta más sencillo recordar enteros). De esta forma, todas las coincidencias alternativas de la misma cadena pueden dirigirse al mismo lugar. En caso de conflicto, la última coincidencia situada en una ranura es la coincidencia correcta. Sin embargo, se puede disponer de una lista completa de varias coincidencias para una única ranura. Vea la colección Group.Captures para obtener información detallada.

Vea también

Otros recursos

Expresiones regulares de .NET Framework