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 d’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 une instance du type Box, et la classe de collection est BoxCollection. Cet exemple de code fait partie d’un exemple plus large 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 de 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. Par conséquent, l’utilisation de foreach est recommandée, au lieu de manipuler directement l’énumérateur.
Les énumérateurs peuvent être utilisés pour lire les données de la collection, mais ils ne peuvent pas être utilisés pour modifier la collection sous-jacente.
Initialement, 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 faire avancer l’énumérateur vers le 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 définit Current à l’élément suivant.
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 à MoveNext retournent également false. Si le dernier appel à MoveNext retourné false, Current n’est pas défini. Vous ne pouvez pas définir Current sur le premier élément de la collection ; vous devez créer une instance d’énumérateur à la place.
La méthode Reset 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 une NotSupportedException. Toutefois, si vous choisissez de le faire, vous devez vous assurer qu’aucun appelant ne s’appuie sur la fonctionnalité de Reset.
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.
L’énumérateur n’a pas d’accès exclusif à la collection ; par conséquent, l’énumération par le biais 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 pendant toute l’énumération. Pour permettre à la collection d’accéder à plusieurs threads pour la lecture et l’écriture, vous devez implémenter votre propre synchronisation.
Les implémentations par défaut des regroupements 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 IEnumerator non générique. Les méthodes MoveNext() et Reset() ne dépendent pas de Tet n’apparaissent que sur l’interface non générique. La propriété Current apparaît sur les deux interfaces et comporte différents types de retour. Implémentez la propriété Current non générique comme implémentation d’interface explicite. Cela permet à tout consommateur de l’interface non générique d’utiliser l’interface générique.
En outre, IEnumerator<T> implémente IDisposable, ce qui vous oblige à implémenter la méthode Dispose(). Cela vous permet de fermer les connexions de base 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’existe aucune ressource supplémentaire à supprimer, fournissez une implémentation Dispose() vide.
Propriétés
| Current |
Obtient l’élément de la collection à la position actuelle de l’énumérateur. |
Méthodes
| Dispose() |
Effectue des tâches définies par l’application associées à la libération, à la libération ou à la réinitialisation des ressources non managées. (Hérité de IDisposable) |
| MoveNext() |
Avance l’énumérateur vers l’élément suivant de la collection. (Hérité de IEnumerator) |
| Reset() |
Définit l’énumérateur à sa position initiale, qui est avant le premier élément de la collection. (Hérité de IEnumerator) |
