performance FirstOrDefault hausse

Question

partie du code:

Dictionary<Calculation, List<PropertyValue>> result = new Dictionary<Calculation, List<PropertyValue>>(); 
while (reader != null && reader.Read()) //it loops about 60000, and it will be bigger 
{ 
    #region create calc and propvalue variables 
    //... 
    #endregion 

    //this FirstOrDefault needs a lot of time 
    tmpElementOfResult = result.Keys.FirstOrDefault(r => r.InnerID == calc.InnerID); 
    if (tmpElementOfResult == null) 
    { 
     result.Add(calc, new List<PropertyValue> { propValue }); 
    } 
    else 
    { 
     result[tmpElementOfResult].Add(propValue); 
    } 
} 

Pourriez-vous me donner une idée comment le rendre plus rapide, parce que maintenant il est environ 25 sec :(

Answer 1

Il semble que vous devriez avoir un? dictionnaire du type de calc.InnerID, au lieu d'un Dictionary<Calc, ...>. de cette façon, vous pouvez faire la recherche beaucoup plus rapidement. Est-ce que vous avez réellement besoin de stocker le Calc lui-même du tout, ou êtes-vous seulement intéressé par l'ID?

Par exemple :

Dictionary<Guid, List<PropertyValue>> result = 
    new Dictionary<Guid, List<PropertyValue>>(); 
while (reader.Read()) 
{ 
    // Work out calc 
    List<PropertyValue> list; 
    if (!result.TryGetValue(calc.InnerID, out list)) 
    { 
     list = new List<PropertyValue>(); 
     result[calc.InnerID] = list; 
    } 
    list.Add(propValue); 
} 

Alternativement, si vous pouvez convertir le lecteur à un IEnumerable<Calc> vous pouvez utiliser:

Lookup<Guid, PropertyValue> result = items.ToLookup(x => x.InnerID, 
                // Or however you get it... 
                x => x.PropertyValue); 

EDIT: Il semble que deux valeurs Calc doivent être considérées comme égales si elles ont le même InnerID, non? Remplacez donc Equals et GetHashCode par Calc pour faire référence au InnerID. Ensuite, vous pouvez simplement utiliser:

Lookup<Calc, PropertyValue> result = items.ToLookup(x => x, 
                // Or however you get it... 
                x => x.PropertyValue); 

... ou vous pouvez utiliser le code comme le premier extrait, mais avec un Dictionary<Calc, ...>:

Dictionary<Calc, List<PropertyValue>> result = 
    new Dictionary<Calc, List<PropertyValue>>(); 
while (reader.Read()) 
{ 
    // Work out calc 
    List<PropertyValue> list; 
    if (!result.TryGetValue(calc, out list)) 
    { 
     list = new List<PropertyValue>(); 
     result[calc] = list; 
    } 
    list.Add(propValue); 
} 

Answer 2

au lieu de

tmpElementOfResult = result.Keys.FirstOrDefault(r => r.InnerID == calc.InnerID); 

utilisation

result.ContainsKey(calc.InnerId); 

pour vérifier si un la clé est présente.

Answer 3

Est-il possible de faire quelque chose comme ceci:

   lookUpForResult = result.ToLookup(x => x.Key.InnerID, x => x.Value); 

       if (lookUpForResult.Contains(calc.InnerID)) 
       { 
        result.Add(calc, new List<PropertyValue> { propValue }); 
       } 
       else 
       { 
        (lookUpForResult[calc.InnerID]).Add(propValue); 
       }