C# IEnumerable

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 maxe 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
16Linguagem de código:  C#  ( cs )

Neste exemplo, o Square()método adiciona os números quadrados de todos os números de 0a maxa 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 yieldpalavra-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 foreachloop.

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 foreachinstrução de loop enumera o elemento da squaressequê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 oddNumbersvariável tem o tipo IEnumerable<int>. Devido à avaliação da consulta adiada, a consulta não é executada até a foreachinstruçã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.