As interfaces IEnumerable e IEnumerator do C # são usadas por coleções como Arrays and Lists para padronizar métodos de loop sobre elas e execução de ações, como filtragem e seleção com instruções LINQ. Discutiremos como eles funcionam e como usá-los.

O que é um enumerável?

O termo “Enumerável” define um objeto que deve ser iterado, passando sobre cada elemento uma vez na ordem. Em C #, um Enumerable é um objeto como uma matriz, lista ou qualquer outro tipo de coleção que implemente o IEnumerable interface. Os enumeráveis ​​padronizam o loop sobre as coleções e permitem o uso da sintaxe de consulta LINQ, bem como outros métodos de extensão úteis, como List.Where() ou List.Select().

Todos IEnumerable interface requer é um método, GetEnumerator(), que retorna um IEnumerator. Então, o que os Enumeradores fazem?

Bem, IEnumerator requer dois métodos, MoveNext() e Current(). MoveNext é o método usado para passar por cima de cada item, aplicando qualquer tipo de lógica iteradora personalizada no processo, e Current é um método usado para obter o item atual após MoveNext é feito. Você acaba com uma interface que define objetos que podem ser enumerados e como lidar com essa enumeração.

Por exemplo, toda vez que você escreve um foreach loop, você está usando enumeradores. Você na verdade não pode usar foreach em uma coleção que não implementa IEnumerable. Quando ele é compilado, um foreach loop assim:

foreach (Int element in list)
 {
 // your code
 }

Torna-se um loop while, que processa até que Enumerable fique sem itens, chamando MoveNext cada vez e definindo a variável iteradora para .Current.

IEnumerator enumerator= list.GetEnumerator();
 while (list.MoveNext())
 {
 element = (Int)enumerator.Current
 // your code
 }

Na maioria das vezes, você deseja implementar manualmente qualquer uma dessas coisas, uma vez que Enumerables como Lists são projetados para serem usados ​​em loops e com métodos LINQ. Mas, se você quiser criar sua própria classe de coleção, poderá fazê-lo implementando IEnumerable e retornando o enumerador da Lista em que você armazena os dados.

Para classes que possuem campos que você gostaria de iterar, esta pode ser uma maneira fácil de limpar o código. Em vez de ter a matriz de dados pública e iterar CustomCollection.dataArray, você pode apenas iterar CustomCollection em si. Obviamente, se você quiser que ela se comporte mais como uma lista adequada, também precisará implementar outras interfaces, como ICollection.

Consultas LINQ usam execução adiada

A coisa mais importante a observar sobre LINQ é que as consultas nem sempre são executadas imediatamente. Muitos métodos retornam Enumerables e usam execução adiada. Em vez de fazer um loop quando a consulta é feita, ele realmente espera até que Enumerable seja usado no loop e, em seguida, faz a consulta durante MoveNext.

Vejamos um exemplo. Esta função pega uma lista de strings e imprime cada item que é maior que um determinado comprimento. Usa Where() para filtrar a lista, e então foreach para imprimir cada elemento.

Esta sintaxe é um pouco confusa, especialmente se você tem o hábito de usar var (o que você definitivamente não deve fazer aqui), uma vez que pode parecer que você está gerando uma nova lista com Where() e, em seguida, iterar essa lista. No caso de um loop foreach, um IEnumerable pode ocupar o lugar de uma List, mas não é uma List - você não pode anexar ou remover itens.

C # é inteligente, porém, e em vez de iterar a lista duas vezes (o que dobraria o tempo de execução sem motivo e alocaria memória inútil), ele apenas joga a lógica de filtragem no foreach ciclo. Isso aqui não é exatamente para o qual seu código é traduzido, mas é uma boa ideia conceituá-lo assim, com a condição e a filtragem sendo destruídas dentro do foreach.

Nos bastidores, ele faz isso anexando a consulta ao Enumerador e retornando um Enumerable que usará a lógica de Where() ao ligar Enumerable.MoveNext(). Se você estiver interessado, pode dar uma olhada em como System.Linq.Enumerable lida com isso em System.Core.

Na verdade, isso pode ter alguns efeitos negativos se você não tomar cuidado. E se, entre o Where() e a execução, a coleção foi modificada? Fazer isso pode fazer com que as consultas pareçam ser realizadas fora de ordem.

Por exemplo, vamos dar a esta mesma função alguma entrada, mas em vez de imprimir imediatamente, vamos acrescentar uma nova palavra à lista antes de foreach. À primeira vista, pode parecer que vai filtrar as letras simples e produzir "Hello World", mas na verdade produz "Hello World Banana", porque a filtragem não é aplicada até MoveNext é chamado durante a iteração real do foreach.

Isso é particularmente sorrateiro, já que nem mesmo tocamos o toPrint variável que é passada para o loop foreach. No entanto, se você anexar .ToList() até o final do Where função, que forçará o C # a realizar uma iteração e retornar uma nova lista. A menos que seja especificamente o que você deseja, é quase sempre melhor economizar tempo de execução e alocações de heap usando foreach com um Enumerable.

O que são corrotinas?

As corrotinas são funções especiais que podem pausar a execução e retornar à rosca principal. Eles são comumente usados ​​para executar ações longas que podem levar algum tempo para terminar, sem fazer com que o aplicativo trave enquanto espera pela rotina. Por exemplo, em jogos em que a taxa de quadros do aplicativo é muito importante, grandes problemas, mesmo na ordem de alguns milissegundos, prejudicariam a experiência do usuário.

As co-rotinas estão intimamente ligadas aos Enumeradores, uma vez que, na verdade, são apenas funções que retornam um enumerador. Isso define um método iterador e você pode usá-lo. Você não precisa fazer muito; apenas altere o tipo de retorno da função para IEnumerator e, em vez de returning algo, você pode apenas yield return, que o define automaticamente como um enumerador sem fazer isso explicitamente.

Então, para quebrar a execução em frames diferentes, você só precisa yield return null sempre que quiser pausar a execução e executar mais do thread principal. Então, para usar este Enumerador, você precisará chamar a função e atribuí-la a uma variável, que você pode chamar MoveNext() em intervalos regulares.

Se você estiver usando o Unity, eles têm um controlador de co-rotina que pode lidar com o processamento de co-rotinas para você, apenas iniciando e interrompendo-as com seus métodos. No entanto, tudo o que realmente faz é ligar MoveNext() uma vez por quadro, verificando se pode processar mais e manipulando o valor de retorno se não for nulo. Você pode lidar com isso facilmente:

Claro, você pode querer funcionalidade extra, como produzir co-rotinas filhas que você terá que adicionar a uma pilha de processamento e produzir expressões como WaitForSeconds ou aguardando a conclusão das funções assíncronas, que você só precisa verificar uma vez por quadro (antes de chamar MoveNext) se a expressão retornar true, continue o processamento. Dessa forma, a co-rotina irá parar completamente até que possa começar a funcionar novamente.

Adicione ao Google Notícias
Neste artigo
  1. O que é um enumerável?
  2. Consultas LINQ usam execução adiada
  3. O que são corrotinas?