Come implementare i metodi dell'interfaccia IEnumerable<>?

Question

Se con questo codice,

public class Pilota<T>
         {
             public T Current { get; set; }
             private T NomePilota { get; set; }
             private T CognomePilota { get; set; }
             public List<T> pilota;
             public Pilota(int NumeroPilota)
             {
                 pilota = (new T[NumeroPilota]).ToList();
                 
             }
         

            public void Add(T nome)
            {
                pilota.Add(nome);
                
            }
}

desiderassi fare derivare la classe da IEnumerable<>, come potrei fare per implementare anche il metodo GetEnumerator, MoveNext e Reset?

Devo crearli tutti,giusto?

Da solo purtroppo non ci riesco,ci provo, ma invano, non arrivo a nessuna soluzione.

Answer 1

Ciao Stef,

Qui hai un ottimo esempio di come fare.

Calcola che per similitudine con l'esempio tu dovresti avere due classi : una classe Pilota che equivarrebbe alla classe Person e una classe Piloti che equivarrebbe alla classe People.

Answer 2

Avevo già dato un occhio a quell'esempio, ma non capisco bene la sintassi utilizzata.

Per esempio qui:

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

    public PeopleEnum GetEnumerator()
    {
        return new PeopleEnum(_people);
    }

Nel primo metodo, come tipo di ritorno viene utilizzato "IEnumerator"? il metodo non viene chiamato soltanto "GetEnumerator()" ma bensì "IEnumerable.GetEnumerator()"? Dico bene? Il metodo GetEnumerator() che farebbe precisamente in questo caso? Perché non riesco a capirlo? Io potrei implementarlo pari pari? Tutte le volte che devo implementarlo, la sintassi rimane sempre questa?

Poi nel return,viene utilizzato il cast per caso?

Nell'esempio viene creato un metodo anche per la classe PeopleEnum, questo perché hanno scelto di farla derivare da IEnumerator? Che a sua volta deriva da IEnumerable? Quindi la classe PeopleEnum deve implementare anche MoveNext e Reset e lo stesso GetEnumerator()?

Answer 3

Ciao Stef,

andiamo per gradi. L'interfaccia IEnumerable consta di un solo metodo da implementare che è appunto GetEnumerator che restituisce un istanza di una classe che implementa l'interfaccia IEnumerator che è l'oggetto che viene iterato per scorrere gli elementi che lo compongono.

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

Qui tu stai dicendo che stai implementando il metodo GetEnumerator della interfaccia IEnumerable.

E lo implementi con un tuo metodo GetEnumerator che riestituisce una istanza della classe PeopleEnum che non fa altro che implementare l'interfaccia IEnumerator.

Answer 4

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

Piano piano ci sto arrivando. Però dovrei capire un po' la sintassi. Quando scrivo IEnumerable.GetEnumerator(), sarebbe come scrivere GetEnumerator() e basta, solo che in quel caso viene usato il metodo esplicito? Non ho ben capito perché viene utilizzata la parola IEnumerator. Nel metodo la prima parola è o il modificatore oppure il tipo di ritorno,quindi IEnumerator è il tipo di ritorno? Quindi implemento il metodo dell'interfaccia IEnumerable.GetEnumerator() che abbia come tipo di ritorno un oggetto dell'interfaccia IEnumerator?Quando faccio return, perché IEnumerator è tra parentesi? comunque come ritorno c'è GetEnumerator(),cioè l'altro metodo implementato da me nella classe PeopleEnum,giusto? e nell'implementazione di quel metodo crea un nuovo oggetto della classe PeopleEnum con un parametro. Dimmi se sbaglio..

In questo modo poi nel Main credo un oggetto, richiamo il metodo GetEnumerator e posso utilizzare il foreach?

Devo sempre fare così per poter implementare il metodo dell'interfaccia IEnumerable? Che poi alla fine non contiene niente,semplicemente richiama un altro mio metodo sempre GetEnumerator. e nel mio metodo GetEnumerator che creo,della mia classe PeopleEnum devo sempre creare un nuovo oggetto dopo il return?

(Comunque ho fatto caso soltanto adesso che l'esempio implementa l'interfaccia in versione non generica, ma è bene imparare anche questa)