C'è un modo migliore per aggregare un dizionario usando LINQ?

Question

Sto cercando di creare un dizionario da una enumerabile, ma ho bisogno di un aggregatore per tutte le chiavi potenzialmente duplicate. L'uso diretto di ToDictionary() causava occasionalmente chiavi duplicate.

In questo caso, ho un certo numero di voci di tempo ({DateTime Date, double Hours}), e se più voci temporali si verificano nello stesso giorno, voglio il tempo totale per quel giorno. Ad esempio, un aggregatore personalizzato, che mi darà una chiave univoca per una voce del dizionario.

C'è un modo migliore per farlo rispetto a questo?

(Questo funziona.)

private static Dictionary<DateTime, double> CreateAggregatedDictionaryByDate(IEnumerable<TimeEntry> timeEntries) 
    { 
     return 
      timeEntries 
       .GroupBy(te => new {te.Date}) 
       .Select(group => new {group.Key.Date, Hours = group.Select(te => te.Hours).Sum()}) 
       .ToDictionary(te => te.Date, te => te.Hours); 
    } 

Penso che sto davvero cercando qualcosa di simile:

IEnumerable<T>.ToDictionary( 
    /* key selector : T -> TKey */, 
    /* value selector : T -> TValue */, 
    /* duplicate resolver : IEnumerable<TValue> -> TValue */); 

così ...

timeEntries.ToDictionary( 
    te => te.Date, 
    te => te.Hours, 
    duplicates => duplicates.Sum()); 

Il 'resolver 'potrebbe essere .First() o .Max() o qualsiasi altra cosa.

O qualcosa di simile.

---

Ho avuto un'implementazione ... e un'altra è comparsa nelle risposte mentre ci stavo lavorando.

Mine:

public static Dictionary<TKey, TValue> ToDictionary<T, TKey, TValue>(
     this IEnumerable<T> input, 
     Func<T, TKey> keySelector, 
     Func<T, TValue> valueSelector, 
     Func<IEnumerable<TValue>, TValue> duplicateResolver) 
    { 
     return input 
      .GroupBy(keySelector) 
      .Select(group => new { group.Key, Value = duplicateResolver(group.Select(valueSelector)) }) 
      .ToDictionary(k => k.Key, k => k.Value); 
    } 

Speravo ci fosse qualcosa di simile già, ma io non credo. Sarebbe una bella aggiunta.

Grazie a tutti :-)

Answer 1

public static Dictionary<KeyType, ValueType> ToDictionary 
    <SourceType, KeyType, ValueType> 
(
    this IEnumerable<SourceType> source, 
    Func<SourceType, KeyType> KeySelector, 
    Func<SourceType, ValueType> ValueSelector, 
    Func<IGrouping<KeyType, ValueType>, ValueType> GroupHandler 
) 
{ 
    Dictionary<KeyType, ValueType> result = source 
    .GroupBy(KeySelector, ValueSelector) 
    .ToDictionary(g => g.Key, GroupHandler); 
} 

chiamato da:

Dictionary<DateTime, double> result = timeEntries.ToDictionary(
    te => te.Date, 
    te => te.Hours, 
    g => g.Sum() 
); 

Answer 2

Se chiavi duplicate è un problema, forse vuoi dire ToLookup? Stesso principio, ma più valori per tasto ...

private static ILookup<DateTime, double> CreateAggregatedDictionaryByDate(IEnumerable<TimeEntry> timeEntries) 
{ 
    return 
     timeEntries 
      .GroupBy(te => new {te.Date}) 
      .Select(group => new {group.Key.Date, Hours = group.Select(te => te.Hours).Sum()}) 
      .ToLookup(te => te.Date, te => te.Hours); 
} 

Quindi è sufficiente fare qualcosa di simile:

var lookup = CreateAggregatedDictionaryByDate(...); 
foreach(var grp in lookup) { 
    Console.WriteLine(grp.Key); // the DateTime 
    foreach(var hours in grp) { // the set of doubles per Key 
     Console.WriteLine(hours) 
    } 
} 

o utilizzare SelectMany ovviamente (from...from).

Answer 3

Se acess indicizzatore di un dizionario e non c'è niente, permette di impostare restituisce una costruzione di default del tipo di dati, nel caso di un doppio sarà 0. avrei forse fare qualcosa di simile

public void blabla(List<TimeEntry> hoho) 
{ 
    Dictionary<DateTime, double> timeEntries = new Dictionary<DateTime, double>(); 
    hoho.ForEach((timeEntry) => 
     { 
      timeEntries[timeEntry.Day] = 0; 
     }); 

    hoho.ForEach((timeEntry) => 
     { 
      timeEntries[timeEntry.Day] += timeEntry.Hours; 
     }); 

} 

Elenco appena utilizzato perché per motivi sconosciuti, l'estensione .ForEach() non è implementata su ienumerable, anche se immagino che l'implementazione sia riga per riga identica, ma si può semplicemente fare un foreach letterale() che è comunque cosa fa sotto le coperte

Penso che dal punto di vista della leggibilità, questo sia il punto attraverso molto più facile di ciò che viene fatto, a meno che non sia quello che stavi cercando di fare ..

Answer 4

Mi piace il tuo metodo perché è chiaro, ma vuoi renderlo più efficiente puoi fare quanto segue che farà tutte le aggregazioni e raggruppamenti in una singola chiamata Aggregate, anche se leggermente contorta.

private static Dictionary<DateTime, double> CreateAggregatedDictionaryByDate(IEnumerable<TimeEntry> timeEntries) 
{ 
    return timeEntries.Aggregate(new Dictionary<DateTime, double>(), 
           (accumulator, entry) => 
            { 
             double value; 
             accumulator.TryGetValue(entry.Date, out value); 
             accumulator[entry.Date] = value + entry.Hours; 
             return accumulator; 
            }); 
} 

Answer 5

Stai cercando qualcosa di simile?

private static Dictionary<DateTime, double> CreateAggregatedDictionaryByDate(IEnumerable<TimeEntry> timeEntries) 
{ 
    return 
     (from te in timeEntries 
     group te by te.Date into grp) 
     .ToDictionary(grp => grp.Key, (from te in grp select te.Hours).Sum()); 
}