Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C#

IEnumerable e IEnumerator não genéricos em System.Collections

IEnumerable fornece um enumerador e IEnumerator mantém a posição na sequência. Uma implementação explícita satisfaz o contrato não genérico sem duplicar a lógica de iteração.

Versão: C# 12 and .NET 8; later runtimes may add compatible features

Sintaxe

using System.Collections;
using System.Collections.Generic;

sealed class Sequence<T> : IEnumerable<T>
{
    public IEnumerator<T> GetEnumerator()
    {
        yield break;
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

System.Collections.IEnumerable representa uma origem de elementos. O seu método GetEnumerator() devolve um System.Collections.IEnumerator que mantém a posição na sequência. O enumerador começa antes do primeiro elemento. Lê Current apenas depois de MoveNext() devolver true e termina a iteração quando devolver false. Reset() serve para repor a posição inicial, mas pode lançar NotSupportedException, como acontece com os iteradores que usam yield. Para recomeçar, obtém um novo enumerador.

IEnumerable<T>, em System.Collections.Generic, herda da interface não genérica IEnumerable, pelo que a classe tem de cumprir ambos os contratos. Expõe um método público que devolva IEnumerator<T> e acrescenta IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();. Esta implementação explícita está acessível através da interface não genérica. Não é uma sobrecarga normal: em C#, não se pode sobrecarregar métodos que só diferem no tipo devolvido. As duas chamadas usam a mesma lógica de iteração.

IEnumerator<T> herda de IEnumerator e IDisposable. A versão genérica de Current é do tipo T; a não genérica devolve object. No exemplo, ler o Current não genérico faz boxing de um int, e foreach (int ...) faz unboxing desse valor. Um iterador com yield fornece ambas as versões de Current. Se escreveres o teu próprio enumerador, podes implementar explicitamente o Current não genérico.

foreach chama MoveNext() e lê Current sem usar Reset(). Também chama Dispose() se o enumerador implementar IDisposable, mesmo quando sais do ciclo mais cedo. Se fizeres a iteração manualmente com IEnumerator, verifica num bloco finally se o enumerador implementa IDisposable e, se for o caso, chama Dispose(): a interface não genérica não exige esse método.

Exemplos

using System;
using System.Collections;
using System.Collections.Generic;

IEnumerable<int> typed = new EvenPair();
IEnumerable untyped = typed;

foreach (int value in typed)
    Console.WriteLine(FormattableString.Invariant($"Generic: {value}"));

foreach (int value in untyped)
    Console.WriteLine(FormattableString.Invariant($"Non-generic: {value}"));

sealed class EvenPair : IEnumerable<int>
{
    public IEnumerator<int> GetEnumerator()
    {
        yield return 2;
        yield return 4;
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

Resultado

Generic: 2
Generic: 4
Non-generic: 2
Non-generic: 4

Ambas as variáveis referenciam o mesmo objeto. O segundo ciclo chama a implementação explícita através de `IEnumerable` e volta a ler `2` e `4`.

Lições relacionadas

  • C# · Lição 38 · Intermédio · Versão: 2

Fontes