Tengo una cadena de búsqueda introducida por un usuario. Normalmente, la cadena de búsqueda se divide utilizando espacios en blanco y luego se realiza una búsqueda OR (un elemento coincide si coincide con alguno de los elementos de la cadena de búsqueda). Quiero proporcionar algunas características de consulta "avanzadas", como la capacidad de usar comillas para encerrar frases literales que contengan espacios en blanco.

Pensé que había forjado una expresión regular decente para dividir las cadenas para mí, pero está demorando un tiempo sorprendentemente largo en ejecutarse (> 2 segundos en mi máquina). Rompí para averiguar dónde estaba el hipo, y lo que es más interesante, parece ocurrir después de la últimaMatch coincide (probablemente, al final de la entrada). Todas las coincidencias hasta el final de la cadena coinciden en menos tiempo de lo que puedo capturar, pero esa última coincidencia (si es lo que es, nada regresa) toma casi todos los 2 segundos.

Esperaba que alguien pudiera tener alguna idea de cómo puedo acelerar un poco esta expresión regular. Sé que estoy usando un look behind con un cuantificador ilimitado pero, como dije, esto no parece causar ningún problema de rendimiento hasta después de que la última coincidencia haya coincidido.

CÓDIGO

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace RegexSandboxCSharp {
    class Program {
        static void Main( string[] args ) {

            string l_input1 = "# one  \"two three\" four five:\"six seven\"  eight \"nine ten\"";

            string l_pattern =
                @"(?<=^([^""]*([""][^""]*[""])?)*)\s+";

            Regex l_regex = new Regex( l_pattern );

            MatchCollection l_matches = l_regex.Matches( l_input1 );
            System.Collections.IEnumerator l_matchEnumerator = l_matches.GetEnumerator();

            DateTime l_listStart = DateTime.Now;
            List<string> l_elements = new List<string>();
            int l_previousIndex = 0;
            int l_previousLength = 0;
            //      The final MoveNext(), which returns false, takes 2 seconds.
            while ( l_matchEnumerator.MoveNext() ) {
                Match l_match = (Match) l_matchEnumerator.Current;
                int l_start = l_previousIndex + l_previousLength;
                int l_length = l_match.Index - l_start;
                l_elements.Add( l_input1.Substring( l_start, l_length ) );

                l_previousIndex = l_match.Index;
                l_previousLength = l_match.Length;
            }
            Console.WriteLine( "List Composition Time: " + ( DateTime.Now - l_listStart ).TotalMilliseconds.ToString() );

            string[] l_terms = l_elements.ToArray();

            Console.WriteLine( String.Join( "\n", l_terms ) );

            Console.ReadKey( true );

        }
    }
}

SALIDA
(Esto es exactamente lo que estoy recibiendo).

uno
"dos tres"
cuatro
cinco seis SIETE"
ocho
"nueve diez"