Procesar grandes conjuntos de datos usando LINQ

Question

Cada vez que escribo un programa del siguiente formulario usando LINQ to SQL, termino con un programa que solo agarra más y más memoria mientras corre y cae en un montón que consume 2GB después de quizás como poco como 25,000 registros. Siempre termino reescribiéndolo usando ADO.NET. ¿Qué estoy haciendo mal?

Aclaración: Esta pregunta no trata sobre la velocidad de procesamiento; las respuestas sobre hacer que avance más rápido no son relevantes.

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

Está presionando el contexto de datos para generar la consulta desde cero cada vez.

Intente utilizar una consulta compilada en su lugar.

Answer 2

podría intentar poner la creación de la DataContext fuera del bucle, no está seguro de la cantidad de memoria que le ahorraría sin embargo.

Quizás pueda llamar a GC.Collect() después de cada ciclo, vea si puede causar la recolección de basura manualmente.

Answer 3

Va a la base de datos dos veces para cada iteración de bucle, una para recuperar la fila y otra para actualizar la fila. Esto no es muy eficiente.

Debe operar en lotes:

• Obtener un conjunto de filas en la delantera al seleccionar en un rango en lugar de un único valor, es decir, 0-100 para el primer lote, 101-200 para el siguiente lote, etc. Esto será más rápido si tiene un índice agrupado definido en la columna Código.

• Crear el contexto de datos antes de entrar en el bucle

• Dentro del bucle, simplemente actualizar los objetos

• SubmitChanges de llamada() después del bucle ha terminado, esto enviará todas las actualizaciones de la base de datos en una sola conexión/transacción

• Repita para el siguiente lote

Debe hacer que el tamaño del lote sea configurable, ya que no puede estar seguro de qué tamaño de lote generará el mejor rendimiento; no lo codifique en la aplicación.

Además, utilizaría SingleOrDefault() con null-checking en lugar de Single(), a menos que pueda garantizar que siempre habrá una fila para cualquier valor de i.

EDIT:

En términos de uso de la memoria, eso es mucho más difícil de controlar, pero no es peculiar de LINQ a SQL, cualquier algoritmo de procesamiento por lotes tiene que lidiar con esto. Si bien no recomiendo usar GC.Collect() en la práctica, generalmente es suficiente como una solución después de procesar un lote grande.

También podría considerar reducir la cantidad de datos que recupera por fila (dependiendo de cuánto sea esto para empezar). Puede crear una nueva entidad que se correlacione con un conjunto mucho más pequeño de columnas de la misma tabla, potencialmente solo una o dos, de modo que cuando seleccione esa entidad solo estará recuperando las columnas con las que pretende trabajar. Esto mejoraría tanto la velocidad como la huella de memoria a medida que menos datos viajan por el cable y los objetos son mucho más pequeños.

Answer 4

No he podido replicar el problema. El uso de la memoria era plano. Rendimiento lento, pero memoria constante.

¿Estás seguro de que no estás goteando en otro lado? ¿Puedes producir una muestra mínima de código que reproduzca el problema?

Editar:

que utiliza el prácticamente el mismo código de ejemplo:

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(); 
     } 
    } 
} 

sin problema.

Así las cosas para descartar:

• Framework versión. Estoy en la última.
• DataContext/entity complexity. Mi tabla de prueba es solo dos campos, Id (int) y Name (nvarchar (max)).

¿Se puede reproducir el problema con el último FW, con una pequeña muestra DataContext?