¿LINQ requiere significativamente más ciclos de procesamiento y memoria que las técnicas de iteración de datos de nivel inferior?

Antecedentes

Recientemente estoy en el proceso de soportar entrevistas tecnológicas extenuantes para puestos que usan la pila .NET, algunas de las cuales incluyen preguntas tontas como esta , y algunas preguntas que son más válidas. Recientemente me encontré con un problema que puede ser válido, pero quiero consultar con la comunidad aquí para estar seguro.

Cuando un entrevistador me preguntó cómo contaría la frecuencia de las palabras en un documento de texto y clasificaría los resultados, respondí que lo haría

1. Utilice un objeto de secuencia para colocar el archivo de texto en la memoria como una cadena.
2. Divida la cadena en una matriz en espacios mientras ignora la puntuación.
3. Use LINQ contra la matriz .GroupBy()y .Count()luego OrderBy()dicho recuento.

Recibí esta respuesta incorrecta por dos razones:

1. Transmitir un archivo de texto completo a la memoria podría ser desastroso. ¿Y si fuera una enciclopedia completa? En cambio, debería transmitir un bloque a la vez y comenzar a construir una tabla hash.
2. LINQ es demasiado costoso y requiere demasiados ciclos de procesamiento. Debería haber creado una tabla hash y, para cada iteración, solo agregar una palabra a la tabla hash si no existiera y luego aumentar su recuento.

La primera razón parece, bueno, razonable. Pero el segundo me da más pausa. Pensé que uno de los puntos de venta de LINQ es que simplemente abstrae las operaciones de nivel inferior como las tablas hash, pero que, bajo el velo, sigue siendo la misma implementación.

Pregunta

Además de unos pocos ciclos de procesamiento adicionales para llamar a métodos abstraídos, ¿LINQ requiere significativamente más ciclos de procesamiento para realizar una tarea de iteración de datos determinada que una tarea de nivel inferior (como construir una tabla hash)?

Diría que la principal debilidad de esta respuesta es menos su uso de Linq y más operadores específicos elegidos. GroupBytoma cada elemento y lo proyecta a una clave y un valor que entran en una búsqueda. En otras palabras, cada palabra agregará algo a la búsqueda.

La implementación ingenua .GroupBy(e => e)almacenará una copia de cada palabra en el material fuente, haciendo que la búsqueda final sea casi tan grande como el material fuente original. Incluso si proyectamos el valor con .GroupBy(e => e, e => null), estamos creando una gran búsqueda de valores pequeños.

Lo que queremos es un operador que conserve solo la información necesaria, que es una copia de cada palabra y el recuento de esa palabra hasta el momento. Para eso, podemos usar Aggregate:

words.Aggregate(new Dictionary<string, int>(), (counts, word) => 
{
    int currentCount;
    counts.TryGetValue(word, currentCount);
    counts[word] = currentCount + 1;
    return counts;
} 

A partir de aquí, hay varias formas en que podríamos intentar hacer esto más rápido:

1. En lugar de crear muchas cadenas mientras se divide, podríamos pasar estructuras que hagan referencia a la cadena original y al segmento que contiene la palabra, y solo copiar el segmento cuando resulte ser una clave única
2. Use Parallel Linq para agregar varios núcleos y luego combine los resultados . Esto es trivial en comparación con el trabajo de piernas requerido para hacer esto a mano.

Creo que tuvo un escape estrecho, el entrevistador realmente no sabía de qué estaba hablando. Peor aún, él cree que hay una respuesta "correcta". Si él fuera alguien para quien quisieras trabajar, esperaría que él tomara tu respuesta inicial, descubriera por qué la elegiste y luego te desafíe a mejorarla si puede encontrar problemas con ella.

LINQ asusta a la gente porque parece magia. En realidad es muy simple (tan simple que necesitarías ser un genio para idearlo)

var result = from item in collection where item=>item.Property > 3 select item;

Se compila en:

IEnumerable<itemType> result = collection.Where(item=>item.property >3);

(Por favor, no grite si tengo la sintaxis incorrecta, es después de la medianoche y estoy en la cama :))

Donde es un método de extensión en IEnumerable que toma una lambda. La lambda es simplemente (en este caso) compilada a un delegado:

bool AMethod(ItemType item)
{
    return item.property >3;
}

El método Where simplemente agrega TODAS las instancias del elemento donde AMethod devuelve verdadero a una colección que se devuelve.

No hay razón para que sea más lento que hacer un foreach y agregar todos los elementos coincidentes a una colección en ese ciclo. De hecho, el método de extensión Where probablemente esté haciendo exactamente eso. La verdadera magia viene cuando necesitas inyectar una alternativa donde los criterios.

Como mencioné anteriormente en mi comentario, algunos de los ejemplos vinculados son muy incorrectos. Y es este tipo de información errónea la que causa los problemas.

Finalmente, si la entrevista te hubiera dado una oportunidad, podrías haber dicho eso:

• LINQ es fácil de leer, especialmente cuando comienzas a presentar proyecciones y agrupaciones interesantes. El código fácil de leer es fácil [y | ier] para mantener el código, lo cual es una victoria.

• Sería realmente fácil medir el rendimiento si realmente fuera un cuello de botella y reemplazarlo por otra cosa.