IEnumerable <T> fornisce due metodi GetEnumerator: qual è la differenza tra loro?

Question

Quando si implementa l'interfaccia IEnumerable<T>, vedo due metodi GetEnumerator: uno che restituisce IEnumerator e altri IEnumerator<T>. Quando dovrei usare l'uno o l'altro?

Answer 1

Se si implementa l'interfaccia generica IEnumerable<T>, si quasi sempre necessario utilizzare il metodo GetEnumerator generica - a meno che non si lanci l'oggetto esplicitamente (non generica) IEnumerable.

Il motivo è la retrocompatibilità con .NET 1.0/1.1 che non supportava i generici.

Answer 2

L'uno è generico, l'altro no. Credo che il compilatore preferisca usare il sovraccarico generico.

Answer 3

Di solito GetEnumerator() chiamate GetEnumerator<T>(), quindi non ci dovrebbero essere molte differenze di comportamento. Per quanto riguarda il motivo per cui ci sono due metodi, questo è fatto per la retrocompatibilità e per l'uso in situazioni in cui T non è di grande interesse (o è solo sconosciuto).

Answer 4

La ragione per cui ci sono due metodi è perché IEnumerable<T> eredita l'interfaccia IEnumerable in modo che si sta vedendo il metodo generico dal IEnumerable<T> e il metodo non generico da IEnumerable.

Ecco come si desidera implementare l'interfaccia nel vostro tipo:

class Foo : IEnumerable<Foo> 
{ 
    public IEnumerator<Foo> GetEnumerator() 
    { 
     // do your thing here 
    } 

    // do a EIMI here and simply call the generic method 
    IEnumerator IEnumerable.GetEnumerator() 
    { 
     this.GetEnumerator(); 
    } 
} 

Answer 5

Di solito implementare entrambi. Uno è la versione più recente e generica che restituisce un enumeratore typesable (IEnumerator<T>). L'altro è compatibile con il codice Legacy (restituisce IEnumerator). Una tipica applicazione è:

public IEnumerator<T> GetEnumerator() { 
    foreach(T item in items) { 
     yield return item; 
    } 
} 

IEnumerator IEnumerable.GetEnumerator() { 
    return GetEnumerator(); 
}