Partager via


IEnumerator Interface

Définition

Prend en charge une itération simple sur une collection non générique.

public interface class IEnumerator
public interface IEnumerator
[System.Runtime.InteropServices.Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
public interface IEnumerator
[System.Runtime.InteropServices.Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
[System.Runtime.InteropServices.ComVisible(true)]
public interface IEnumerator
type IEnumerator = interface
[<System.Runtime.InteropServices.Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")>]
type IEnumerator = interface
[<System.Runtime.InteropServices.Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type IEnumerator = interface
Public Interface IEnumerator
Dérivé
Attributs

Exemples

L’exemple de code suivant illustre l’implémentation des interfaces IEnumerable et IEnumerator pour une collection personnalisée. Dans cet exemple, les membres de ces interfaces ne sont pas explicitement appelés, mais ils sont implémentés pour prendre en charge l’utilisation de foreach (for each en Visual Basic) pour itérer dans la collection.

using System;
using System.Collections;

// Simple business object.
public class Person
{
    public Person(string fName, string lName)
    {
        this.firstName = fName;
        this.lastName = lName;
    }

    public string firstName;
    public string lastName;
}

// Collection of Person objects. This class
// implements IEnumerable so that it can be used
// with ForEach syntax.
public class People : IEnumerable
{
    private Person[] _people;
    public People(Person[] pArray)
    {
        _people = new Person[pArray.Length];

        for (int i = 0; i < pArray.Length; i++)
        {
            _people[i] = pArray[i];
        }
    }

// Implementation for the GetEnumerator method.
    IEnumerator IEnumerable.GetEnumerator()
    {
       return (IEnumerator) GetEnumerator();
    }

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

// When you implement IEnumerable, you must also implement IEnumerator.
public class PeopleEnum : IEnumerator
{
    public Person[] _people;

    // Enumerators are positioned before the first element
    // until the first MoveNext() call.
    int position = -1;

    public PeopleEnum(Person[] list)
    {
        _people = list;
    }

    public bool MoveNext()
    {
        position++;
        return (position < _people.Length);
    }

    public void Reset()
    {
        position = -1;
    }

    object IEnumerator.Current
    {
        get
        {
            return Current;
        }
    }

    public Person Current
    {
        get
        {
            try
            {
                return _people[position];
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }
}

class App
{
    static void Main()
    {
        Person[] peopleArray = new Person[3]
        {
            new Person("John", "Smith"),
            new Person("Jim", "Johnson"),
            new Person("Sue", "Rabon"),
        };

        People peopleList = new People(peopleArray);
        foreach (Person p in peopleList)
            Console.WriteLine(p.firstName + " " + p.lastName);
    }
}

/* This code produces output similar to the following:
 *
 * John Smith
 * Jim Johnson
 * Sue Rabon
 *
 */
Imports System.Collections

' Simple business object.
Public Class Person

    Public Sub New(ByVal fName As String, ByVal lName As String)
        Me.firstName = fName
        Me.lastName = lName
    End Sub


    Public firstName As String
    Public lastName As String
End Class

' Collection of Person objects, which implements IEnumerable so that
' it can be used with ForEach syntax.
Public Class People
    Implements IEnumerable

    Private _people() As Person

    Public Sub New(ByVal pArray() As Person)
        _people = New Person(pArray.Length - 1) {}

        Dim i As Integer
        For i = 0 To pArray.Length - 1
            _people(i) = pArray(i)
        Next i
    End Sub

    ' Implementation of GetEnumerator.
    Public Function GetEnumerator() As IEnumerator _
      Implements IEnumerable.GetEnumerator

        Return New PeopleEnum(_people)
    End Function

End Class

' When you implement IEnumerable, you must also implement IEnumerator.
Public Class PeopleEnum
    Implements IEnumerator

    Public _people() As Person

    ' Enumerators are positioned before the first element
    ' until the first MoveNext() call.
    Dim position As Integer = -1

    Public Sub New(ByVal list() As Person)
        _people = list
    End Sub

    Public Function MoveNext() As Boolean Implements IEnumerator.MoveNext
        position = position + 1
        Return (position < _people.Length)
    End Function

    Public Sub Reset() Implements IEnumerator.Reset
        position = -1
    End Sub

    Public ReadOnly Property Current() As Object Implements IEnumerator.Current
        Get
            Try
                Return _people(position)
            Catch ex As IndexOutOfRangeException
                Throw New InvalidOperationException()
            End Try
        End Get
    End Property
End Class

Class App
    Shared Sub Main()
        Dim peopleArray() As Person = { _
            New Person("John", "Smith"), _
            New Person("Jim", "Johnson"), _
            New Person("Sue", "Rabon")}

        Dim peopleList As New People(peopleArray)
        Dim p As Person
        For Each p In peopleList
            Console.WriteLine(p.firstName + " " + p.lastName)
        Next

    End Sub
End Class

' This code produces output similar to the following:
' 
' John Smith
' Jim Johnson
' Sue Rabon

Remarques

IEnumerator est l’interface de base de tous les énumérateurs non génériques. Son équivalent générique est l’interface System.Collections.Generic.IEnumerator<T>.

L’instruction foreach du langage 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.

La méthode Reset est fournie pour l’interopérabilité COM et n’a pas besoin d’être entièrement implémentée ; Au lieu de cela, l’implémenteur peut lever une NotSupportedException.

Initialement, l’énumérateur est positionné avant le premier élément de la collection. Vous devez appeler la méthode MoveNext pour faire avancer l’énumérateur vers le premier élément de la collection avant de lire la valeur de Current; sinon, Current n’est pas défini.

Current retourne le même objet jusqu’à ce que MoveNext ou Reset 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.

Pour définir Current sur le premier élément de la collection, vous pouvez appeler Reset, s’il est implémenté, suivi de MoveNext. Si Reset n’est pas implémenté, vous devez créer une instance d’énumérateur pour revenir au premier élément de la collection.

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. Même lorsqu’une collection est synchronisée, d’autres threads peuvent toujours modifier la collection, ce qui provoque la levée d’une exception par l’énumérateur. Pour garantir la sécurité des threads pendant l’énumération, vous pouvez verrouiller la collection pendant toute l’énumération ou intercepter les exceptions résultant des modifications apportées par d’autres threads.

Propriétés

Current

Obtient l’élément de la collection à la position actuelle de l’énumérateur.

Méthodes

MoveNext()

Avance l’énumérateur vers l’élément suivant de la collection.

Reset()

Définit l’énumérateur à sa position initiale, qui est avant le premier élément de la collection.

S’applique à

Voir aussi