IEnumerable vs List - O que usar? Como eles funcionam?

Tenho algumas dúvidas sobre como funcionam os enumeradores e o LINQ. Considere estas duas seleções simples:

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

ou

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

Alterei os nomes dos meus objetos originais para que isso pareça um exemplo mais genérico. A consulta em si não é tão importante. O que eu quero perguntar é o seguinte:

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

1. Percebi que se eu usar IEnumerable, quando depurar e inspecionar "sel", que nesse caso é o IEnumerable, ele possui alguns membros interessantes: "inner", "outer", "innerKeySelector" e "outerKeySelector", esses dois últimos aparecem para ser delegados. O membro "interno" não possui instâncias "Animal", mas instâncias "Espécies", o que foi muito estranho para mim. O membro "externo" contém instâncias "Animal". Presumo que os dois delegados determinem qual entra e o que sai dela?

2. Percebi que, se eu usar "Distinto", o "interno" conterá 6 itens (isso está incorreto, pois apenas 2 são Distintos), mas o "externo" conterá os valores corretos. Novamente, provavelmente os métodos delegados determinam isso, mas isso é um pouco mais do que eu sei sobre IEnumerable.

3. Mais importante, qual das duas opções é a melhor em termos de desempenho?

A conversão da lista do mal via .ToList()?

Ou talvez usando o enumerador diretamente?

Se puder, explique um pouco ou ative alguns links que explicam esse uso do IEnumerable.

IEnumerabledescreve o comportamento, enquanto List é uma implementação desse comportamento. Ao usar IEnumerable, você dá ao compilador a chance de adiar o trabalho até mais tarde, possivelmente otimizando ao longo do caminho. Se você usar ToList (), força o compilador a reificar os resultados imediatamente.

Sempre que estou "empilhando" expressões LINQ, eu uso IEnumerable, porque especificando apenas o comportamento, dou ao LINQ a chance de adiar a avaliação e possivelmente otimizar o programa. Lembre-se de como o LINQ não gera o SQL para consultar o banco de dados até que você o enumere? Considere isto:

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

Agora você tem um método que seleciona uma amostra inicial ("AllSpotted"), além de alguns filtros. Então agora você pode fazer isso:

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

Então, é mais rápido usar a lista novamente IEnumerable? Somente se você quiser impedir que uma consulta seja executada mais de uma vez. Mas é melhor no geral? Bem, acima, Leopardos e Hienas são convertidos em consultas SQL únicas cada , e o banco de dados retorna apenas as linhas relevantes. Mas se tivéssemos retornado uma lista de AllSpotted(), ela pode ser executada mais lentamente porque o banco de dados pode retornar muito mais dados do que o necessário, e perdemos ciclos fazendo a filtragem no cliente.

Em um programa, pode ser melhor adiar a conversão de sua consulta em uma lista até o final, portanto, se eu vou enumerar Leopardos e Hienas mais de uma vez, faria o seguinte:

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

Há um artigo muito bom escrito por: TechBlog de Claudio Bernasconi aqui: Quando usar IEnumerable, ICollection, IList e List

Aqui estão alguns pontos básicos sobre cenários e funções:

Uma classe que implementa IEnumerablepermite que você use a foreachsintaxe.

Basicamente, ele possui um método para obter o próximo item da coleção. Ele não precisa que toda a coleção esteja na memória e não sabe quantos itens estão nela, foreachapenas continua recebendo o próximo item até que ele se esgote.

Isso pode ser muito útil em determinadas circunstâncias, por exemplo, em uma tabela massiva de banco de dados, você não deseja copiar tudo na memória antes de começar a processar as linhas.

Agora Listimplementa IEnumerable, mas representa a coleção inteira na memória. Se você possui um IEnumerablee você chama, .ToList()cria uma nova lista com o conteúdo da enumeração na memória.

Sua expressão linq retorna uma enumeração e, por padrão, a expressão é executada quando você itera usando o foreach. Uma IEnumerableinstrução linq é executada quando você itera o foreach, mas você pode forçá-lo a iterar mais cedo usando .ToList().

Aqui está o que eu quero dizer:

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 ) ...

Ninguém mencionou uma diferença crucial, ironicamente respondida em uma pergunta encerrada como duplicada.

IEnumerable é somente leitura e Lista não.

Consulte Diferença prática entre List e IEnumerable

O mais importante a ser observado é que, usando o Linq, a consulta não é avaliada imediatamente. Ele é executado apenas como parte da iteração, resultando IEnumerable<T>em um foreach- é o que todos os delegados estranhos estão fazendo.

Portanto, o primeiro exemplo avalia a consulta imediatamente chamando ToListe colocando os resultados da consulta em uma lista.
O segundo exemplo retorna um IEnumerable<T>que contém todas as informações necessárias para executar a consulta posteriormente.

Em termos de desempenho, a resposta é que depende . Se você precisar que os resultados sejam avaliados de uma só vez (por exemplo, você está alterando as estruturas que está consultando mais tarde ou se não quiser que a iteração IEnumerable<T>demore muito tempo) use uma lista. Caso contrário, use um IEnumerable<T>. O padrão deve ser usar a avaliação sob demanda no segundo exemplo, pois geralmente usa menos memória, a menos que haja um motivo específico para armazenar os resultados em uma lista.

A vantagem do IEnumerable é a execução adiada (geralmente com bancos de dados). A consulta não será executada até que você efetue um loop através dos dados. É uma consulta aguardando até que seja necessária (também conhecida como carregamento lento).

Se você chamar ToList, a consulta será executada ou "materializada", como eu gostaria de dizer.

Há prós e contras para ambos. Se você chamar ToList, poderá remover algum mistério sobre quando a consulta é executada. Se você seguir o IEnumerable, terá a vantagem de que o programa não realiza nenhum trabalho até que seja realmente necessário.

Vou compartilhar um conceito mal usado no qual caí em um dia:

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 atual

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

Explicação

Conforme outras respostas, a avaliação do resultado foi adiada até a chamada ToListou métodos de chamada semelhantes, por exemploToArray .

Então, eu posso reescrever o código neste 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() );

Jogar arround

https://repl.it/E8Ki/0

Se tudo o que você deseja fazer é enumerá-los, use o IEnumerable.

Cuidado, porém, que alterar a coleção original que está sendo enumerada é uma operação perigosa - nesse caso, você desejará ToListprimeiro. Isso criará um novo elemento de lista para cada elemento na memória, enumerando IEnumerablee, portanto, terá menos desempenho se você enumerar apenas uma vez - mas mais seguro e, às vezes, os Listmétodos forem úteis (por exemplo, acesso aleatório).

Além de todas as respostas postadas acima, aqui estão meus dois centavos. Existem muitos outros tipos além de List que implementam IEnumerable como ICollection, ArrayList etc. Portanto, se tivermos IEnumerable como parâmetro de qualquer método, podemos passar qualquer tipo de coleção para a função. Ou seja, podemos ter um método para operar em abstração e não em nenhuma implementação específica.

Existem muitos casos (como uma lista infinita ou uma lista muito grande) em que IEnumerable não pode ser transformado em uma lista. Os exemplos mais óbvios são todos os números primos, todos os usuários do facebook com seus detalhes ou todos os itens no ebay.

A diferença é que os objetos "Lista" são armazenados "aqui e agora", enquanto os objetos "IEnumerable" funcionam "apenas um de cada vez". Portanto, se eu estiver analisando todos os itens no ebay, um de cada vez seria algo que até um computador pequeno pode suportar, mas ".ToList ()" certamente me esgotaria a memória, não importando o tamanho do meu computador. Nenhum computador pode, por si só, conter e manipular uma quantidade tão grande de dados.

[Edit] - Escusado será dizer - não é "isso ou aquilo". geralmente faria sentido usar uma lista e um IEnumerable na mesma classe. Nenhum computador no mundo poderia listar todos os números primos, porque, por definição, isso exigiria uma quantidade infinita de memória. Mas você poderia facilmente pensar em um class PrimeContainerque contém um IEnumerable<long> primes, que por razões óbvias também contém um SortedList<long> _primes. todos os números primos calculados até agora. o próximo primo a ser verificado seria executado apenas contra os primos existentes (até a raiz quadrada). Dessa forma, você obtém os dois primos um de cada vez (IEnumerable) e uma boa lista de "primos até agora", que é uma boa aproximação de toda a lista (infinita).