IEnumerable vs List - ¿Qué usar? ¿Cómo trabajan?

Tengo algunas dudas sobre cómo funcionan los enumeradores y LINQ. Considere estas dos selecciones simples:

List<Animal> sel = (from animal in Animals 
                    join race in Species
                    on animal.SpeciesKey equals race.SpeciesKey
                    select animal).Distinct().ToList();

o

IEnumerable<Animal> sel = (from animal in Animals 
                           join race in Species
                           on animal.SpeciesKey equals race.SpeciesKey
                           select animal).Distinct();

Cambié los nombres de mis objetos originales para que parezca un ejemplo más genérico. La consulta en sí no es tan importante. Lo que quiero preguntar es esto:

foreach (Animal animal in sel) { /*do stuff*/ }

1. Me di cuenta de que si utilizo IEnumerable, cuando depuro e inspecciono "sel", que en ese caso es el IEnumerable, tiene algunos miembros interesantes: "inner", "external", "innerKeySelector" y "externalKeySelector", estos últimos 2 aparecen ser delegados El miembro "interno" no tiene instancias de "Animal", sino instancias de "Especies", lo cual fue muy extraño para mí. El miembro "externo" contiene instancias "animales". Supongo que los dos delegados determinan qué entra y qué sale.

2. Me di cuenta de que si uso "Distinct", el "interno" contiene 6 elementos (esto es incorrecto ya que solo 2 son distintos), pero el "externo" contiene los valores correctos. De nuevo, probablemente los métodos delegados determinan esto, pero esto es un poco más de lo que sé sobre IEnumerable.

3. Lo más importante, ¿cuál de las dos opciones es la mejor en cuanto a rendimiento?

La conversión Lista mal a través de .ToList()?

¿O tal vez usando el enumerador directamente?

Si puede, explique también un poco o arroje algunos enlaces que expliquen este uso de IEnumerable.

IEnumerabledescribe el comportamiento, mientras que List es una implementación de ese comportamiento. Cuando lo usa IEnumerable, le da al compilador la oportunidad de diferir el trabajo hasta más tarde, posiblemente optimizando en el camino. Si usa ToList (), fuerza al compilador a reificar los resultados de inmediato.

Siempre que estoy "apilando" expresiones LINQ, utilizo IEnumerable, porque al especificar el comportamiento solo le doy a LINQ la oportunidad de diferir la evaluación y posiblemente optimizar el programa. ¿Recuerdas que LINQ no genera el SQL para consultar la base de datos hasta que la enumeras? Considera esto:

public IEnumerable<Animals> AllSpotted()
{
    return from a in Zoo.Animals
           where a.coat.HasSpots == true
           select a;
}

public IEnumerable<Animals> Feline(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Felidae"
           select a;
}

public IEnumerable<Animals> Canine(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Canidae"
           select a;
}

Ahora tiene un método que selecciona una muestra inicial ("AllSpotted"), más algunos filtros. Entonces ahora puedes hacer esto:

var Leopards = Feline(AllSpotted());
var Hyenas = Canine(AllSpotted());

Entonces, ¿es más rápido usar List over IEnumerable? Solo si desea evitar que una consulta se ejecute más de una vez. ¿Pero es mejor en general? Bueno, en lo anterior, los leopardos y las hienas se convierten en consultas SQL individuales cada uno , y la base de datos solo devuelve las filas que son relevantes. Pero si hubiéramos devuelto una Lista de AllSpotted(), entonces podría funcionar más lentamente porque la base de datos podría devolver muchos más datos de los que realmente se necesitan, y desperdiciamos ciclos haciendo el filtrado en el cliente.

En un programa, puede ser mejor diferir la conversión de su consulta a una lista hasta el final, por lo que si voy a enumerar a través de Leopardos y Hienas más de una vez, haría esto:

List<Animals> Leopards = Feline(AllSpotted()).ToList();
List<Animals> Hyenas = Canine(AllSpotted()).ToList();

Hay un muy buen artículo escrito por: Claudio Bernasconi TechBlog aquí: Cuándo usar IEnumerable, ICollection, IList and List

Aquí algunos puntos básicos sobre escenarios y funciones:

Una clase que implementa le IEnumerablepermite usar la foreachsintaxis.

Básicamente tiene un método para obtener el siguiente elemento de la colección. No necesita que toda la colección esté en la memoria y no sabe cuántos elementos contiene, foreachsolo sigue obteniendo el siguiente elemento hasta que se agota.

Esto puede ser muy útil en ciertas circunstancias, por ejemplo, en una tabla de base de datos masiva, no desea copiar todo en la memoria antes de comenzar a procesar las filas.

Ahora Listimplementa IEnumerable, pero representa la colección completa en la memoria. Si tiene un IEnumerabley llama .ToList(), crea una nueva lista con el contenido de la enumeración en la memoria.

Su expresión linq devuelve una enumeración y, de forma predeterminada, la expresión se ejecuta cuando itera utilizando foreach. Una IEnumerableinstrucción linq se ejecuta cuando itera foreach, pero puede forzarla a iterar antes usando .ToList().

Esto es lo que quiero decir:

var things = 
    from item in BigDatabaseCall()
    where ....
    select item;

// this will iterate through the entire linq statement:
int count = things.Count();

// this will stop after iterating the first one, but will execute the linq again
bool hasAnyRecs = things.Any();

// this will execute the linq statement *again*
foreach( var thing in things ) ...

// this will copy the results to a list in memory
var list = things.ToList()

// this won't iterate through again, the list knows how many items are in it
int count2 = list.Count();

// this won't execute the linq statement - we have it copied to the list
foreach( var thing in list ) ...

Nadie mencionó una diferencia crucial, irónicamente respondió a una pregunta cerrada como un duplicado de esto.

IEnumerable es de solo lectura y List no.

Consulte la diferencia práctica entre List y IEnumerable

Lo más importante a tener en cuenta es que, utilizando Linq, la consulta no se evalúa de inmediato. Solo se ejecuta como parte de iterar a través del resultado IEnumerable<T>en un foreach- eso es lo que están haciendo todos los delegados extraños.

Entonces, el primer ejemplo evalúa la consulta inmediatamente llamando ToListy colocando los resultados de la consulta en una lista.
El segundo ejemplo devuelve un IEnumerable<T>que contiene toda la información necesaria para ejecutar la consulta más adelante.

En términos de rendimiento, la respuesta es que depende . Si necesita que los resultados se evalúen de inmediato (por ejemplo, está mutando las estructuras que está consultando más adelante, o si no desea que la iteración IEnumerable<T>tome mucho tiempo) use una lista. De lo contrario, use un IEnumerable<T>. El valor predeterminado debería ser usar la evaluación a pedido en el segundo ejemplo, ya que generalmente usa menos memoria, a menos que haya una razón específica para almacenar los resultados en una lista.

La ventaja de IEnumerable es la ejecución diferida (generalmente con bases de datos). La consulta no se ejecutará hasta que realmente recorra los datos. Es una consulta esperando hasta que sea necesaria (también conocida como carga diferida).

Si llama a ToList, la consulta se ejecutará o se "materializará" como me gusta decir.

Hay pros y contras para ambos. Si llama a ToList, puede eliminar algún misterio sobre cuándo se ejecuta la consulta. Si te quedas con IEnumerable, obtienes la ventaja de que el programa no hace ningún trabajo hasta que realmente sea necesario.

Compartiré un concepto mal utilizado en el que caí un día:

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));


// updating existing list
names[0] = "ford";

// Guess what should be printed before continuing
print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

Resultado Esperado

// I was expecting    
print( startingWith_M.ToList() ); // mercedes, mazda
print( startingWith_F.ToList() ); // fiat, ferrari

Resultado actual

// what printed actualy   
print( startingWith_M.ToList() ); // mazda
print( startingWith_F.ToList() ); // ford, fiat, ferrari

Explicación

Según otras respuestas, la evaluación del resultado fue diferida hasta la llamada ToListo métodos de invocación similares, por ejemploToArray .

Entonces puedo reescribir el código en este caso como:

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

// updating existing list
names[0] = "ford";

// before calling ToList directly
var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));

print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

Jugar alrededor

https://repl.it/E8Ki/0

Si todo lo que quiere hacer es enumerarlos, use el IEnumerable.

Sin embargo, tenga en cuenta que cambiar la colección original que se enumera es una operación peligrosa; en este caso, ToListprimero querrá hacerlo . Esto creará un nuevo elemento de lista para cada elemento en la memoria, enumerando IEnumerabley, por lo tanto, será menos eficaz si solo enumera una vez, pero es más seguro y, a veces, los Listmétodos son útiles (por ejemplo, en acceso aleatorio).

Además de todas las respuestas publicadas anteriormente, aquí están mis dos centavos. Hay muchos otros tipos además de List que implementa IEnumerable como ICollection, ArrayList, etc. Así que si tenemos IEnumerable como parámetro de cualquier método, podemos pasar cualquier tipo de colección a la función. Es decir, podemos tener un método para operar en abstracción, no en ninguna implementación específica.

Hay muchos casos (como una lista infinita o una lista muy grande) donde IEnumerable no se puede transformar en una Lista. Los ejemplos más obvios son todos los números primos, todos los usuarios de Facebook con sus detalles o todos los artículos en eBay.

La diferencia es que los objetos "Lista" se almacenan "aquí y ahora", mientras que los objetos "IEnumerable" funcionan "solo uno a la vez". Entonces, si estoy revisando todos los elementos en eBay, uno a la vez sería algo que incluso una computadora pequeña puede manejar, pero ".ToList ()" seguramente me dejaría sin memoria, sin importar cuán grande fuera mi computadora. Ninguna computadora puede por sí misma contener y manejar una cantidad tan grande de datos.

[Editar] - No hace falta decir que no es "ni esto ni aquello". a menudo tendría sentido usar una lista y un IEnumerable en la misma clase. Ninguna computadora en el mundo podría enumerar todos los números primos, porque por definición esto requeriría una cantidad infinita de memoria. Pero podría pensar fácilmente en un class PrimeContainerque contiene un IEnumerable<long> primes, que por razones obvias también contiene un SortedList<long> _primes. Todos los números primos calculados hasta ahora. el próximo primo que se comprobará solo se ejecutará contra los primos existentes (hasta la raíz cuadrada). De esa manera, obtienes ambos: números primos uno a la vez (IEnumerable) y una buena lista de "números primos hasta ahora", que es una aproximación bastante buena de toda la lista (infinita).