Eu tenho uma string de pesquisa inserida por um usuário. Normalmente, a cadeia de pesquisa é dividida usando espaço em branco e, em seguida, uma pesquisa OR é executada (um item corresponde se corresponder a qualquer um dos elementos da cadeia de pesquisa). Eu quero fornecer alguns recursos de consulta "avançados", como a capacidade de usar aspas para incluir frases literais que contenham espaços em branco.

Eu achava que eu tinha conseguido um regex decente para dividir as cordas para mim, mas está demorando um tempo surpreendentemente longo para executar (> 2 segundos na minha máquina). Eu terminei para descobrir exatamente onde o soluço estava, e ainda mais interessante, parece ocorrer após o últimoMatch é correspondido (presumivelmente, no final da entrada). Todas as partidas até o final da seqüência de caracteres corresponder em menos tempo, então eu posso capturar, mas essa última partida (se é isso que é - nada retorna) leva quase todos os 2 segundos.

Eu estava esperando que alguém pudesse ter alguma idéia de como eu posso acelerar esse regex um pouco. Eu sei que estou usando um lookbehind com um quantificador ilimitado, mas, como eu disse, isso não parece causar problemas de desempenho até que a última correspondência tenha sido correspondida.

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 );

        }
    }
}

SAÍDA
(Isso é exatamente o que eu estou recebendo.)

1
"dois três"
quatro
cinco seis sete"
oito
"nove dez"