Reemplazo más rápido para Regex

Question

Tengo en clase alrededor de 100 Regex llamadas, cada llamada cubre diferentes tipos de datos en el protocolo de texto, pero tengo muchos archivos y en función de los análisis regex tomó el 88% de la ejecución de mi código.

muchos este tipo de código:

{ 
    Match m_said = Regex.Match(line, @"(.*) said,", RegexOptions.IgnoreCase); 
    if (m_said.Success) 
    { 
    string playername = ma.Groups[1].Value; 
    // some action 
    return true; 
    } 
} 

{ 
    Match ma = Regex.Match(line, @"(.*) is connected", RegexOptions.IgnoreCase); 
    if (ma.Success) 
    { 
    string playername = ma.Groups[1].Value; 
    // some action 
    return true; 
    } 
} 
{ 
    Match ma = Regex.Match(line, @"(.*): brings in for (.*)", RegexOptions.IgnoreCase); 
    if (ma.Success) 
    { 
    string playername = ma.Groups[1].Value; 
    long amount = Detect_Value(ma.Groups[2].Value, line); 
    // some action 
    return true; 
    } 
} 

alguna manera de reemplazar Regex con alguna otra solución más rápida?

Answer 1

Para expresiones regulares que se prueban en el bucle, es a menudo más rápido es precompilación ellos fuera del bucle y justo prueba ellos dentro del bucle.

Debe declarar las diferentes expresiones regulares primero con sus respectivos patrones y solo llamar al Match() con el texto para probar en un segundo paso.

Answer 2

Se podría tratar de compilar la expresión regular de antemano o considerar la combinación de todas las expresiones expresiones regulares individuales en un (monstruo) Regex:

Match m_said = Regex.Match(line, 
      @"(.*) (said|(is connected)|...|...),", 
      RegexOptions.IgnoreCase); 

entonces usted puede probar el segundo grupo de captura para determinar qué ocurrió tipo de partido.

Answer 3

Sé expresión regular puede hacer muchas cosas, pero aquí es un punto de referencia con la expresión regular vs vs char.Split string.split

http://www.dotnetperls.com/split en la sección de los Puntos de Referencia

Answer 4

Aparte de precompilar su expresión regular, usted podría gane (probablemente mucho más) beneficios de rendimiento escribiendo una expresión regular más precisa. En este sentido, .* es casi siempre una mala elección:

(.*) is connected significa: Primero que coincida con la cadena de toda (esa es la parte .*), a continuación, dar marcha atrás un carácter a la vez hasta que sea posible para que coincida con is connected.

Ahora, a menos que la cuerda sea muy corta o is connected aparece muy cerca del final de la cuerda, eso implica un gran retroceso que lleva tiempo.

Así que si puede refinar la coincidencia permitida, puede mejorar el rendimiento.

Por ejemplo, si solo se permiten caracteres alfanuméricos, entonces (\w+) is connected será bueno. Si se trata de cualquier tipo de caracteres que no sean espacios en blanco, entonces use (\S+) is connected. Etc., dependiendo de las reglas para una coincidencia válida.

En su ejemplo concreto, no parece estar haciendo nada con la coincidencia capturada, por lo que incluso podría descartar la expresión regular por completo y solo buscar una subcadena fija. Cuál método será el más rápido al final depende mucho de su entrada y requisitos reales.

Answer 5

No sé si puede volver a utilizar las expresiones, o si el método se llama varias veces, pero si es así, debe precompilar sus expresiones regulares. Prueba esto:

private static readonly Regex xmlRegex = new Regex("YOUR EXPRESSION", RegexOptions.Compiled); 

En su muestra, cada vez que se utiliza el método que 'recoge' la expresión, pero esto es innnecesario como la expresión es una constante.Ahora está precompilado, compilado solo una vez. La desventaja es que la primera vez que accede a la expresión, es un poco más lento.