Qual è il modo più efficiente per gestire la raccolta di grandi dimensioni

0

Ho un problema piuttosto difficile:

Ricevo periodicamente un Dictionary<decimal, int> subDict contenente 100 record dove

  • decimal è un prezzo
  • e int è importo

Il risultato che mi serve è un dataGrid che mostri i prezzi con gli importi. Ma non riesco a visualizzare la sottocartella direttamente, perché spesso alla sottolista mancano alcuni prezzi:

subDict:

  • Prezzo | Importo
  • 100,0001 | 192
  • 100.0005 | 123
  • 100.0007 | 2
  • 100.0008 | 123

sopra deve essere visualizzato come:

  • Prezzo | Importo
  • 100,0001 | 192
  • 100.0002 | 0
  • 100.0003 | 0
  • 100.0004 | 123
  • 100.0005 | 0
  • 100.0006 | 0
  • 100.0007 | 2
  • 100.0008 | 123

Devo memorizzare un prezzo con 4 cifre decimali, tuttavia l'intervallo di prezzo può essere compreso tra 0 e 10 000. Il requisito finale è: una volta fatto clic sull'importo in DataGrid, devo essere in grado di ottenere l'accesso a tutti i valori nella riga.

Quindi ho deciso di chiedere aiuto - qualcuno può pensare ad una buona strategia per affrontare un problema del genere?

Un'idea che mi è venuta in mente sarebbe quella di inizializzare Dicionary<decimal, int> bigDictionary contenente ogni prezzo nell'intervallo.

Tuttavia, se inizializzo questo dizionario con tutti i prezzi, con granularità specificata (ad esempio passo 0.0001), finisco con 10.000 * 10.000 record. Questa è una lista piuttosto ampia, che richiede una notevole quantità di memoria. Naturalmente è facile collegarlo a DataGrid in WPF, quindi questo può funzionare, ma a mio parere è molto inefficiente.

L'altra idea che ho sarebbe di salvare i prezzi in entrata a un Dictionary<decimal, int> smallDict ma poi avrei bisogno di avere un qualche tipo di meccanismo per aggiornare DataGrid in questo modo, che i gap di prezzo sarebbero riempiti al volo. Inoltre avrei dovuto in qualche modo mantenere il dataGrid ordinato in base al prezzo.

La prima idea che sono in grado di implementare. Il secondo, non ne ho idea, quindi qualsiasi codice sarebbe eccellente.

Sarei fantastico per qualsiasi idea! Grazie per il tuo tempo

    
posta Macin 30.11.2013 - 20:05
fonte

1 risposta

1

Considerando la creazione di un qualche tipo di interfaccia di drill-down. Invece di cercare immediatamente di visualizzare 10.000 * 10.000 record per l'utente, riepiloga questi 100.000.000 di record in 100 intervalli. Lascia che l'utente selezioni l'intervallo desiderato e poi "ingrandisca" e divida quell'intervallo in 100 sotto-intervalli. Continua a ripetere fino ad arrivare al livello di dettaglio e mostra le 100 voci che appartengono all'intervallo genitore.

Supponendo che la fascia di prezzo sia compresa tra 0.0000 e 9.999.9999 e desideri visualizzare 100 record alla volta, i tuoi 100 intervalli di livello superiore saranno 0 - 99.9999, 100 - 199.9999, Ecc. La "larghezza" dei tuoi intervalli sarà:

  1. 100 (primo livello)
  2. 1
  3. .01
  4. .0001 (livello di dettaglio)

Questo si prende cura del tuo problema di visualizzazione. E il problema dell'utilizzo della memoria? Crea un dizionario di visualizzazione e associa la tua griglia ad esso. Ogni volta che l'utente esegue lo zoom avanti o indietro, compilare semplicemente questo dictionary con i dati riepilogati o dettagliati che corrispondono all'intervallo corrente e al livello di zoom. Probabilmente avrai bisogno di alcuni controlli extra per mostrare lo zoom / intervallo corrente per fornire un modo per l'ingrandimento e lo zoom dell'utente.

    
risposta data 01.12.2013 - 02:18
fonte

Leggi altre domande sui tag