Elaborazione di set di dati di grandi dimensioni tramite LINQ

Question

Ogni volta che scrivo un programma del modulo sottostante utilizzando LINQ to SQL, si finisce con un programma che acquisisce sempre più memoria mentre viene eseguito e cade in un heap consumando 2 GB dopo forse come poco più di 25.000 dischi. Finisco sempre per riscriverlo usando ADO.NET. Che cosa sto facendo di sbagliato?

Precisazione: questa domanda non riguarda la velocità di elaborazione; le risposte su come farlo andare più veloce non hanno alcuna rilevanza.

foreach (int i=0; i<some_big_number; i++) 
{ 
    using (myDC dc = new myDC()) // my DataContext 
    { 
     myRecord record = (from r in dc.myTable where r.Code == i select r).Single(); 

     // do some LINQ queries using various tables from the data context 
     // and the fields from this 'record'. i carefully avoid referencing 
     // any other data context than 'dc' in here because I want any cached 
     // records to get disposed of when 'dc' gets disposed at the end of 
     // each iteration. 

     record.someField = newValueJustCalculatedAbove; 
     dc.SubmitChanges(); 
    } 
} 

Answer 1

State esercitando pressione sul contesto dei dati per generare la query da zero ogni volta.

Prova invece a utilizzare una query compilata.

Answer 2

si potrebbe provare a mettere la creazione del DataContext al di fuori del ciclo for, non è sicuro la quantità di memoria che potrebbe risparmiare però.

Forse è possibile chiamare GC.Collect() dopo ogni ciclo, vedere se è possibile causare manualmente la garbage collection.

Answer 3

Si sta andando al database due volte per ogni iterazione del ciclo - una volta per recuperare la riga, quindi di nuovo per aggiornare la riga. Questo non è molto efficiente.

Si dovrebbe operare in lotti:

• Prendi un set di righe sulla parte anteriore selezionando su una gamma piuttosto che un singolo valore, cioè 0-100 per il primo lotto, 101-200 per la prossima lotto e così via. Questo sarà più veloce se si dispone di un indice cluster definito nella colonna Codice.

• Creare il contesto dati prima di entrare nel ciclo

• All'interno del ciclo, basta aggiornare gli oggetti

• SubmitChanges call() dopo il ciclo è finito, questo invierà tutti gli aggiornamenti al database in una singola connessione/transazione

• Ripetere l'operazione per il lotto successivo

Si dovrebbe rendere configurabile la dimensione del batch, in quanto non si può essere sicuri di quale dimensione del batch produrrà le migliori prestazioni - non fissarlo con hardcode nell'applicazione.

Inoltre, vorrei utilizzare SingleOrDefault() con null-checking anziché Single(), a meno che non si possa garantire che ci sarà sempre una riga per qualsiasi valore di i.

EDIT:

In termini di utilizzo della memoria, che è molto più difficile da controllare, ma non è peculiare di LINQ to SQL, qualsiasi algoritmo di elaborazione batch ha a che fare con questo. Mentre non è consigliabile utilizzare GC.Collect() nella pratica, di solito è sufficiente come soluzione alternativa dopo l'elaborazione di un batch di grandi dimensioni.

Si potrebbe anche cercare di ridurre la quantità di dati che si recuperano per riga (a seconda di quanto deve cominciare). È possibile creare una nuova entità che esegue il mapping su un insieme molto più piccolo di colonne della stessa tabella, potenzialmente solo uno o due, in modo che quando si seleziona quell'entità si stiano recuperando solo le colonne con le quali si intende iniziare. Ciò migliorerebbe la velocità e l'impronta della memoria man mano che meno dati viaggiano sul filo e gli oggetti sono molto più piccoli.

Answer 4

Non è stato possibile replicare il problema. L'utilizzo della memoria era piatto. Prestazioni lente, ma memoria costante.

Sei sicuro di non perdere altrove? Potete produrre un campione di codice minimale che riproduca il problema?

Edit:

ho usato il praticamente lo stesso codice di esempio:

for (int ii = 1; ii < 200000; ii++) 
{ 
    using (var dc = new PlayDataContext()) 
    { 
     var record = 
      (from r in dc.T1s where r.Id == ii select r).SingleOrDefault(); 
     if (record != null) 
     { 
      record.Name = "S"; 
      dc.SubmitChanges(); 
     } 
    } 
} 

senza alcun problema.

Quindi le cose per escludere:

• Framework versione. Sono in ultima posizione.
• DataContext/complessità entità. La mia tabella di test è composta da soli due campi e Id (int) e un nome (nvarchar (max)).

È possibile riprodurre il problema con l'ultimo FW, con un piccolo esempio di DataContext?