IEnumerator<T> Interface
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Prend en charge une itération simple sur une collection générique.
generic <typename T>
public interface class IEnumerator : IDisposable, System::Collections::IEnumeratorpublic interface IEnumerator<out T> : IDisposable, System.Collections.IEnumeratorpublic interface IEnumerator<T> : IDisposable, System.Collections.IEnumeratortype IEnumerator<'T> = interface
interface IEnumerator
interface IDisposabletype IEnumerator<'T> = interface
interface IDisposable
interface IEnumeratorPublic Interface IEnumerator(Of Out T)
Implements IDisposable, IEnumeratorPublic Interface IEnumerator(Of T)
Implements IDisposable, IEnumeratorParamètres de type
- T
Type des objets à énumérer.
Ce paramètre de type est covariant. Cela signifie que vous pouvez utiliser le type spécifié ou tout type plus dérivé. Pour plus d’informations sur la covariance et la contravariance, consultez Covariance et contravariance dans les génériques.- Dérivé
- Implémente
Exemples
L’exemple suivant montre une implémentation de l’interface IEnumerator<T> pour une classe de collection d’objets personnalisés. L’objet personnalisé est un instance du type Box, et la classe de collection est BoxCollection. Cet exemple de code fait partie d’un exemple plus grand fourni pour l’interface ICollection<T> .
// Defines the enumerator for the Boxes collection.
// (Some prefer this class nested in the collection class.)
public class BoxEnumerator : IEnumerator<Box>
{
private BoxCollection _collection;
private int curIndex;
private Box curBox;
public BoxEnumerator(BoxCollection collection)
{
_collection = collection;
curIndex = -1;
curBox = default(Box);
}
public bool MoveNext()
{
//Avoids going beyond the end of the collection.
if (++curIndex >= _collection.Count)
{
return false;
}
else
{
// Set current box to next item in collection.
curBox = _collection[curIndex];
}
return true;
}
public void Reset() { curIndex = -1; }
void IDisposable.Dispose() { }
public Box Current
{
get { return curBox; }
}
object IEnumerator.Current
{
get { return Current; }
}
}
' Defines the enumerator for the Boxes collection.
' (Some prefer this class nested in the collection class.)
Public Class BoxEnumerator
Implements IEnumerator(Of Box)
Private _collection As BoxCollection
Private curIndex As Integer
Private curBox As Box
Public Sub New(ByVal collection As BoxCollection)
MyBase.New()
_collection = collection
curIndex = -1
curBox = Nothing
End Sub
Private Property Box As Box
Public Function MoveNext() As Boolean _
Implements IEnumerator(Of Box).MoveNext
curIndex = curIndex + 1
If curIndex = _collection.Count Then
' Avoids going beyond the end of the collection.
Return False
Else
'Set current box to next item in collection.
curBox = _collection(curIndex)
End If
Return True
End Function
Public Sub Reset() _
Implements IEnumerator(Of Box).Reset
curIndex = -1
End Sub
Public Sub Dispose() _
Implements IEnumerator(Of Box).Dispose
End Sub
Public ReadOnly Property Current() As Box _
Implements IEnumerator(Of Box).Current
Get
If curBox Is Nothing Then
Throw New InvalidOperationException()
End If
Return curBox
End Get
End Property
Private ReadOnly Property Current1() As Object _
Implements IEnumerator.Current
Get
Return Me.Current
End Get
End Property
End Class
' Defines two boxes as equal if they have the same dimensions.
Public Class BoxSameDimensions
Inherits EqualityComparer(Of Box)
Public Overrides Function Equals(ByVal b1 As Box, ByVal b2 As Box) As Boolean
If b1.Height = b2.Height And b1.Length = b2.Length And b1.Width = b2.Width Then
Return True
Else
Return False
End If
End Function
Public Overrides Function GetHashCode(ByVal bx As Box) As Integer
Dim hCode As Integer = bx.Height ^ bx.Length ^ bx.Width
Return hCode.GetHashCode()
End Function
End Class
Remarques
IEnumerator<T> est l’interface de base pour tous les énumérateurs génériques.
L’instruction foreach du langage C# (for each en C++, For Each en Visual Basic) masque la complexité des énumérateurs. Il est donc recommandé d'utiliser foreach plutôt que de manipuler l'énumérateur directement.
Les énumérateurs peuvent être utilisés pour lire les données de la collection, mais ils ne permettent pas de modifier la collection sous-jacente.
Au départ, l'énumérateur est positionné avant le premier élément de la collection. À cette position, Current n'est pas défini. Par conséquent, vous devez appeler MoveNext pour avancer l'énumérateur jusqu'au premier élément de la collection avant de lire la valeur de Current.
Current retourne le même objet jusqu'à ce que MoveNext soit appelé. MoveNext affecte l'élément suivant à Current.
Si MoveNext passe la fin de la collection, l’énumérateur est positionné après le dernier élément de la collection et MoveNext retourne false. Lorsque l’énumérateur se trouve à cette position, les appels suivants pour MoveNext retourner falseégalement . Si le dernier appel à MoveNext retourné false, Current n’est pas défini. Vous ne pouvez pas attribuer de nouveau Current au premier élément de la collection ; vous devez créer une nouvelle instance de l’énumérateur à la place.
La Reset méthode est fournie pour l’interopérabilité COM. Elle n’a pas nécessairement besoin d’être implémentée; au lieu de cela, l’implémenteur peut simplement lever un NotSupportedException. Toutefois, si vous choisissez de le faire, vous devez vous assurer qu’aucun appelant ne s’appuie sur la Reset fonctionnalité.
Si des modifications sont apportées à la collection, telles que l’ajout, la modification ou la suppression d’éléments, le comportement de l’énumérateur n’est pas défini.
Comme l’énumérateur ne dispose pas d’un accès exclusif à la collection, l’énumération d’une collection n’est pas intrinsèquement une procédure thread-safe. Pour garantir la sécurité des threads pendant l'énumération, vous pouvez verrouiller la collection tout au long de cette opération. Pour permettre à plusieurs threads d’accéder en lecture et en écriture à la collection, vous devez implémenter votre propre synchronisation.
Les implémentations par défaut de collections dans l'espace de noms System.Collections.Generic ne sont pas synchronisées.
Notes pour les responsables de l’implémentation
L’implémentation de cette interface nécessite l’implémentation de l’interface non générique IEnumerator . Les MoveNext() méthodes et Reset() ne dépendent Tpas de et apparaissent uniquement sur l’interface non générique. La Current propriété apparaît sur les deux interfaces et a différents types de retour. Implémentez la propriété non générique Current en tant qu’implémentation d’interface explicite. Cela permet à tout consommateur de l’interface non générique de consommer l’interface générique.
En outre, IEnumerator<T> implémente IDisposable, ce qui vous oblige à implémenter la Dispose() méthode . Cela vous permet de fermer connexions aux bases de données ou de libérer des handles de fichiers ou des opérations similaires lors de l’utilisation d’autres ressources. S’il n’y a pas de ressources supplémentaires à supprimer, fournissez une implémentation vide Dispose() .
Propriétés
| Current |
Obtient l’élément de la collection situé à la position actuelle de l’énumérateur. |
Méthodes
| Dispose() |
Exécute les tâches définies par l'application associées à la libération ou à la redéfinition des ressources non managées. (Hérité de IDisposable) |
| MoveNext() |
Avance l’énumérateur à l’élément suivant de la collection. (Hérité de IEnumerator) |
| Reset() |
Rétablit l’énumérateur à sa position initiale, qui précède le premier élément de la collection. (Hérité de IEnumerator) |