Qual è il modo più veloce per contare le nuove righe in una stringa .NET di grandi dimensioni?

Question

C'è un modo per migliorare questo:

private static int CountNewlines(string s) 
{ 
    int len = s.Length; 
    int c = 0; 
    for (int i=0; i < len; i++) 
    { 
     if (s[i] == '\n') c++; 
    } 
    return c; 
} 

Sono particolarmente preoccupato per la funzione di accesso voce sulla corda. Non sono sicuro se si tratta solo di aritmetica puntatore come C/C++.

Answer 1

ho provato queste implementazioni

private static int Count1(string s) 
{ 
    int len = s.Length; 
    int c = 0; 
    for (int i=0; i < len; i++) 
    { 
     if (s[i] == '\n') c++; 
    } 
    return c+1; 
} 

private static int Count2(string s) 
{ 
    int count = -1; 
    int index = -1; 

    do 
    { 
     count++; 
     index = s.IndexOf('\n', index + 1); 
    } 
    while (index != -1); 

    return count+1; 
} 

private static int Count3(string s) 
{ 
    return s.Count(c => c == '\n') + 1; 
} 


private static int Count4(string s) 
{ 
    int n = 0; 
    foreach(var c in s) 
    { 
     if (c == '\n') n++; 
    } 
    return n+1; 
} 

private static int Count5(string s) 
{ 
    var a = s.ToCharArray(); 
    int c = 0; 
    for (int i=0; i < a.Length; i++) 
    { 
     if (a[i]=='\n') c++; 
    } 
    return c+1; 
} 

Qui ci sono i miei risultati di temporizzazione per 100000 iterazioni su una serie di ~ 25k. Più basso è più veloce.

   Time Factor 
Count1 4.8581503  1.4 
Count2 4.1406059  1.2 
Count3 45.3614124 13.4 
Count4 3.3896130  1.0 
Count5 5.9304543  1.7 

Sorprendentemente, per me, l'attuazione Enumeratore stato il più veloce per me, da un grado significativo - 20% più veloce rispetto a quello successivo più vicino implementazione. I risultati sono stati ripetibili, indipendentemente dall'ordine in cui sono stati eseguiti i metodi. Ho anche usato una fase di riscaldamento per assicurare effetti transitori (jit, ecc.).

Questo era per una versione di build (/ optimize +)

Answer 2

Questa è probabilmente l'opzione più efficiente - l'elemento accessor è ottimizzato internamente e lo si può trattare come se eseguisse il puntatore aritmetico.

Answer 3

è possibile convertire la stringa in un array di caratteri con "ToCharArray();" ma non credo che migliorerà le prestazioni .. potresti provare a usare il codice non sicuro (puntatore) invece di ma che ha i suoi svantaggi.

Answer 4

Sono abbastanza sicuro che non sarà molto più lento della conversione della stringa in byte e del controllo di quelli, se non più veloce. La classe String dovrebbe essere altamente ottimizzata.

Se questo è un grande stringa, forse un esecuzione parallela da più thread renderà le cose più veloce :-)

Answer 5

Ne fanno un metodo di istanza, se lo userete in un ciclo.

Answer 6

Beh, String implementa IEnumerable<char>, quindi mi piacerebbe provare:

s.Count(c => c == '\n') 

bello come questo sembra, il metodo originale è 30x più veloce :)

non ho rinunciato alla IEnumerable ancora, così ho anche provato:

int n = 0; 
foreach(var c in s) 
{ 
    if (c == '\n') n++; 
} 
return n; 

che sembra veloce come il metodo originale.