L'implementazione esplicita di GetEnumerator dell'interfaccia causa l'overflow dello stack

Question

Sto facendo del mio meglio per codificare le interfacce quando possibile, ma sto riscontrando alcuni problemi quando si tratta di raccolte. Ad esempio, ecco un paio di interfacce che vorrei usare.

public interface IThing {} 

public interface IThings : IEnumerable<IThing> {} 

Ecco le implementazioni. Per implementare IEnumerable <IThing>, è necessario implementare esplicitamente IEnumerable <IThing> .GetEnumerator() in Oggetti.

public class Thing : IThing {} 

public class Things : List<Thing>, IThings 
{ 
    IEnumerator<IThing> IEnumerable<IThing>.GetEnumerator() 
    { 
     // This calls itself over and over 
     return this.Cast<IThing>().GetEnumerator(); 
    } 
} 

Il problema è che l'implementazione di GetEnumerator causa uno stack overflow. Si chiama più e più volte. Non riesco a capire perché avrebbe deciso di chiamare quell'implementazione di GetEnumerator invece dell'implementazione fornita dal risultato di questo.Cast <IThing>(). Qualche idea su cosa sto facendo male? Sono pronto a scommettere che sia qualcosa di estremamente stupido ...

Ecco qualche semplice codice di prova per le classi di cui sopra:

static void Enumerate(IThings things) 
{ 
    foreach (IThing thing in things) 
    { 
     Console.WriteLine("You'll never get here."); 
    } 
} 

static void Main() 
{ 
    Things things = new Things(); 
    things.Add(new Thing()); 

    Enumerate(things); 
} 

Answer 1

Utilizzare questo invece:

public class Things : List<Thing>, IThings 
    { 
     IEnumerator<IThing> IEnumerable<IThing>.GetEnumerator() 
     { 
      foreach (Thing t in this) 
      { 
       yield return t; 
      } 
     } 
    } 

Oppure si potrebbe lavorare con contenimento, invece.

Answer 2

IEnumerator<IThing> IEnumerable<IThing>.GetEnumerator() 
{ 
    // This calls itself over and over 
    return this.Cast<IThing>().GetEnumerator(); 
} 

E 'una chiamata ricorsiva senza condizione di interruzione, si sta andando per ottenere uno stack overflow, perché sta per riempire molto velocemente lo stack.

Stai eseguendo il casting su un'interfaccia, che non fa ciò che pensi che faccia. Alla fine stai chiamando this.GetEnumerator(); qual è la funzione in cui ti trovi già, quindi ricorsero. Forse intendi base.GetEnumerator();

Answer 3

Sembra abbastanza ovvio che this.Cast<IThing>() restituisce un oggetto IEnumerable. O almeno lo fa senza l'implementazione di Cast.

Answer 4

In genere, è probabile che si desideri disaccoppiare l'implementazione della raccolta Things dall'implementazione dell'oggetto Thing. La classe Things è in grado di funzionare con qualsiasi implementazione di IThing, non solo la classe Thing.

In particolare:

public class Things : List<IThing>, IThings 
{ 
} 

In questo caso, non c'è bisogno di sostituire l'implementazione predefinita di GetEnumerator(), l'implementazione di base è già digitato correttamente per voi. Ciò eviterà l'overflow che stai attualmente riscontrando e soddisfa il caso di test che hai fornito.

Answer 5

Non so se una domanda si qualifica come risposta, ma portami con me Sono un consulente; P Perché vuoi implementare il GetEnumerator()?

Si sta derivando dalla lista se si cambia in Elenco si ottiene il GetEnumerator gratuitamente.

Attenzione anche che derivare da List è generalmente una cattiva idea. dovresti considerare la derivazione da IEnumerable <() IThings> (come già stai facendo, che è atm superflua poiché List implementa anche quell'interfaccia) o se hai bisogno dell'interfaccia List e non solo dell'Iistumer implementato IList e mantieni un oggetto List privato.In questo modo si ottiene il pieno controllo circa l'attuazione ed esporre solo un contratto di progettazione (attraverso le interfacce implementate)

Answer 6

Questo è un bell'esempio della necessità del linguaggio e del runtime di comprendere covarianza e controvarianza.

In C# 4, si può semplicemente utilizzare

IEnumerator<IThing> IEnumerable<IThing>.GetEnumerator() 
{ 
    return base.GetEnumerator(); 
}