IEnumerator<T> Interface

Définition

generic <typename T>
public interface class IEnumerator : IDisposable, System::Collections::IEnumerator

public interface IEnumerator<out T> : IDisposable, System.Collections.IEnumerator

public interface IEnumerator<T> : IDisposable, System.Collections.IEnumerator

type IEnumerator<'T> = interface
    interface IEnumerator
    interface IDisposable

type IEnumerator<'T> = interface
    interface IDisposable
    interface IEnumerator

Public Interface IEnumerator(Of Out T)
Implements IDisposable, IEnumerator

Public Interface IEnumerator(Of T)
Implements IDisposable, IEnumerator

Paramètres de type

Dérivé

Microsoft.Extensions.Primitives.StringTokenizer.Enumerator

Microsoft.Extensions.Primitives.StringValues.Enumerator

Microsoft.IO.Enumeration.FileSystemEnumerator<TResult>

Microsoft.VisualC.StlClr.DequeEnumerator<TValue>

Microsoft.VisualC.StlClr.HashEnumerator<TKey,TValue>

Plus…

Implémente

IEnumerator IDisposable

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

Méthodes

S’applique à

Voir aussi

• IEnumerable<T>
• ICollection<T>
• System.Collections