Resumo : neste tutorial, você aprenderá sobre IEnumerable<T>
a interface C#, que é a chave para o LINQ.
Introdução à interface C# IEnumerable<T>
O IEnumerable<T>
é uma interface que representa uma sequência de objetos que podem ser enumerados.
O IEnumerable<T>
possui um único método GetEnumerator()
que retorna um IEnumerator<T>
que pode ser usado para iterar por uma sequência de objetos.
A IEnumerator<T>
interface possui os seguintes membros importantes:
Current
– retorna o elemento atual na sequência.MoveNext()
– move o iterador para o próximo elemento na sequência.
O exemplo a seguir define um método Square()
que aceita um argumento inteiro chamado max
e retorna uma sequência de números quadrados de números de 0 a max
:
using static System.Console;
IEnumerable<int> Square(int max)
{
var results = new List<int>();
for (int i = 0; i < max; i++)
{
results.Add(i * i);
}
return results;
}
foreach (var n in Square(5))
{
WriteLine(n);
}
Linguagem de código: C# ( cs )
Saída:
0
1
4
9
16
Linguagem de código: C# ( cs )
Neste exemplo, o Square()
método adiciona os números quadrados de todos os números de 0
a max
a uma coleção List<int>
.
Caso você queira construir uma grande lista de números quadrados, a implementação do Square()
método não é otimizada para memória porque cria antecipadamente uma lista enorme de números quadrados na memória.
Seria melhor se o Square()
método retornasse um número quadrado por vez com base na solicitação do chamador.
O Square()
método a seguir usa a yield
palavra-chave para criar uma sequência de números quadrados, um de cada vez, conforme solicitado pelo chamador:
using static System.Console;
IEnumerable<int> Square(int max)
{
for (int i = 0; i < max; i++)
{
yield return i * i;
}
}
var squares = Square(5);
foreach (var n in squares)
{
WriteLine(n);
}
Linguagem de código: C# ( cs )
Neste exemplo, o Square()
método não será executado até que seu resultado (quadrados) seja enumerado. Uma maneira de enumerar a sequência é usá-la em um foreach
loop.
Portanto, a linha a seguir não executa o Square()
método imediatamente:
var squares = Square(5);
Linguagem de código: C# ( cs )
Em vez disso, esperará até que a sequência de quadrados seja enumerada. Isso é chamado de avaliação preguiçosa .
Quando a foreach
instrução de loop enumera o elemento da squares
sequência, Square()
é executado o método que produz um número quadrado, um de cada vez, em cada iteração:
foreach (var n in squares)
{
WriteLine(n);
}
Linguagem de código: C# ( cs )
IEnumerable<T> e LINQ
As consultas LINQ dependem muito de avaliação lenta. No LINQ, a avaliação lenta é frequentemente chamada de execução de consulta adiada ou avaliação de consulta adiada .
A avaliação de consulta adiada é importante porque permite definir uma consulta em um ponto e usá-la mais tarde, exatamente quando desejar, quantas vezes forem necessárias. Por exemplo:
using static System.Console;
var numbers = new List<int> { 1, 5, 2, 8, 9 };
var oddNumbers = numbers
.Where(number => number % 2 != 0)
.Select(number => number);
foreach (var number in oddNumbers)
{
WriteLine(number);
}
Linguagem de código: C# ( cs )
Neste exemplo, a oddNumbers
variável tem o tipo IEnumerable<int>
. Devido à avaliação da consulta adiada, a consulta não é executada até a foreach
instrução.
Resumo
IEnumerable<T>
A interface usa avaliação lenta, ou seja, a sequência não é gerada até ser avaliada.- Por causa do
IEnumerable<T>
, o LINQ pode trabalhar com grandes sequências de objetos sem exigir memória excessiva.