LINQ méthode pour ajouter des éléments à un dictionnaire

J'essaie d'en apprendre un peu plus sur LINQ par la mise en œuvre de Peter Norvig de correcteur orthographique en C#.

La première partie consiste à prendre une grande fichier de mots (environ 1 million) et de le mettre dans un dictionnaire où l' key est la parole et la value est le nombre d'occurrences.

Je serais normalement ce faire comme suit:

foreach (var word in allWords)                                                    
{           
    if (wordCount.ContainsKey(word))
        wordCount[word]++;
    else
        wordCount.Add(word, 1);
}

allWords est un IEnumerable<string>

Dans LINQ, je suis actuellement en train de faire comme ceci:

var wordCountLINQ = (from word in allWordsLINQ
                         group word by word
                         into groups
                         select groups).ToDictionary(g => g.Key, g => g.Count());  

Je compare les 2 dictionnaires en regardant toutes les <key, value> et qu'ils sont identiques, de sorte qu'ils produisent les mêmes résultats.

La foreach boucle prend 3.82 secs et la requête LINQ prend 4.49 secs

Je suis le calendrier à l'aide de la fonction Chronomètre de la classe et je suis en cours d'exécution en mode RELEASE. Je ne pense pas que le rendement est mauvais, je me demandais juste si il y avait une raison pour la différence.

Je fais la requête LINQ dans un moyen inefficace ou ai-je raté quelque chose?

Mise à jour: voici le plein de référence exemple de code:

public static void TestCode()
{
    //File can be downloaded from http://norvig.com/big.txt and consists of about a million words.
    const string fileName = @"path_to_file";
    var allWords = from Match m in Regex.Matches(File.ReadAllText(fileName).ToLower(), "[a-z]+", RegexOptions.Compiled)
                   select m.Value;

    var wordCount = new Dictionary<string, int>();
    var timer = new Stopwatch();            
    timer.Start();
    foreach (var word in allWords)                                                    
    {           
        if (wordCount.ContainsKey(word))
            wordCount[word]++;
        else
            wordCount.Add(word, 1);
    }
    timer.Stop();

    Console.WriteLine("foreach loop took {0:0.00} ms ({1:0.00} secs)\n",
            timer.ElapsedMilliseconds, timer.ElapsedMilliseconds / 1000.0);

    //Make LINQ use a different Enumerable (with the exactly the same values), 
    //if you don't it suddenly becomes way faster, which I assmume is a caching thing??
    var allWordsLINQ = from Match m in Regex.Matches(File.ReadAllText(fileName).ToLower(), "[a-z]+", RegexOptions.Compiled)
                   select m.Value;

    timer.Reset();
    timer.Start();
    var wordCountLINQ = (from word in allWordsLINQ
                            group word by word
                            into groups
                            select groups).ToDictionary(g => g.Key, g => g.Count());  
    timer.Stop();

    Console.WriteLine("LINQ took {0:0.00} ms ({1:0.00} secs)\n",
            timer.ElapsedMilliseconds, timer.ElapsedMilliseconds / 1000.0);                     
}
Il n'est pas possible de faire des commentaires sur la différence, sauf si vous affichez le code de référence.
J'ai juste ajouté que dans la question pour vous.

OriginalL'auteur Matt Warren | 2010-01-22