Peut-on utiliser GetEnumerator () sans utiliser l'interface IEnumerable?
-
04-10-2019 - |
Question
J'ai une classe appelée PRIMES et cette classe implémente GetEnumerator () sans mettre en oeuvre l'interface IEnumerable.
public class Primes
{
private long min;
private long max;
public Primes()
: this(2, 100)
{
}
public IEnumerator GetEnumerator()
{...}
Je ne comprends pas. Am quelque chose que je manque?
La solution
Tout d'abord, comme d'autres ont dit que vous pouvez présenter vos propres méthodes sans mettre en œuvre les interfaces de toute façon - vous pouvez écrire votre propre méthode de Dispose
sans mettre en œuvre IDisposable
etc. Pour les interfaces bien connues, je vous suggère ce qui est presque une mauvaise idée (comme les lecteurs aura certaines attentes), mais il est tout à fait valable.
Plus important encore, la déclaration de foreach
en C # peut travail sans IEnumerable
être impliqué. Le compilateur fait effectivement duck typing compilation sur les noms GetEnumerator()
, Current
et MoveNext()
. Ce fut principalement pour permettre fortement typé (et non-boxing) itération en C # 1, avant de génériques. Voir la section 8.8.4 de la spécification C # 3 pour plus de détails.
Cependant, il est généralement une mauvaise idée de le faire maintenant si vous ne voulez pouvoir facilement itérer sur le contenu d'une instance en tant que collection - et en effet, je vous suggère de mettre en œuvre IEnumerable<T>
à la place de seulement IEnumerable
.
Autres conseils
oui vous pouvez. même vous pouvez l'utiliser dans foreach
. Le seul problème que les objets de cette classe ne peuvent pas être jetés à IEnumerable
bien qu'ils mettent en œuvre la méthode nécessaire.
Il n'y a aucune raison que vous devez mettre en œuvre IEnumerable
afin de créer une fonction appelée GetEnumerator
qui retourne un IEnumerator
, que seulement signifie que vous ne serez pas en mesure de fournir une instance de ce type à quelque chose qui attend un IEnumerable
.
une interface assure un contrat, cela ne signifie pas que vous ne pouvez pas avoir une méthode avec la même signature que l'un dans l'interface sur une classe qui n'impliment pas l'interface.