IEnumerator<T> Interface

Definitie

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

Type parameters

Afgeleid

Microsoft.VisualC.StlClr.DequeEnumerator<TValue>

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

Microsoft.VisualC.StlClr.ListEnumerator<TValue>

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

Microsoft.VisualC.StlClr.VectorEnumerator<TValue>

Meer…

Implementeringen

IEnumerator IDisposable

Voorbeelden

In het volgende voorbeeld ziet u een implementatie van de IEnumerator<T> interface voor een verzamelingsklasse van aangepaste objecten. Het aangepaste object is een exemplaar van het type Boxen de verzamelingsklasse is BoxCollection. Dit codevoorbeeld maakt deel uit van een groter voorbeeld voor de ICollection<T> interface.

// 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

Opmerkingen

IEnumerator<T> is de basisinterface voor alle algemene opsommingen.

De instructie foreach van de C#-taal (For Each in Visual Basic) verbergt de complexiteit van de opsommingen. Daarom wordt het gebruik foreach aanbevolen in plaats van de opsomming rechtstreeks te bewerken.

Enumerators kunnen worden gebruikt om de gegevens in de verzameling te lezen, maar ze kunnen niet worden gebruikt om de onderliggende verzameling te wijzigen.

In eerste instantie wordt de enumerator vóór het eerste element in de verzameling weergegeven. Op deze positie Current is niet gedefinieerd. Daarom moet u de opsomming doorschakelen MoveNext naar het eerste element van de verzameling voordat u de waarde van Current.

Current retourneert hetzelfde object totdat MoveNext het wordt aangeroepen. MoveNext wordt ingesteld Current op het volgende element.

Als MoveNext het einde van de verzameling wordt doorgegeven, wordt de enumerator geplaatst na het laatste element in de verzameling en MoveNext wordt het resultaat geretourneerd false. Wanneer de enumerator zich op deze positie bevindt, worden volgende aanroepen ook MoveNext geretourneerd false. Als de laatste aanroep die moet MoveNext worden geretourneerd false, Current niet is gedefinieerd. U kunt niet opnieuw instellen Current op het eerste element van de verzameling. U moet in plaats daarvan een nieuw enumerator-exemplaar maken.

De Reset methode wordt geboden voor COM-interoperabiliteit. Het hoeft niet noodzakelijkerwijs te worden geïmplementeerd; In plaats daarvan kan de implementeerfunctie gewoon een NotSupportedException. Als u er echter voor kiest om dit te doen, moet u ervoor zorgen dat er geen bellers vertrouwen op de Reset functionaliteit.

Als er wijzigingen worden aangebracht in de verzameling, zoals het toevoegen, wijzigen of verwijderen van elementen, is het gedrag van de enumerator niet gedefinieerd.

De enumerator heeft geen exclusieve toegang tot de verzameling; Daarom is het inventariseren via een verzameling intrinsiek geen thread-veilige procedure. Om de veiligheid van threads tijdens de inventarisatie te garanderen, kunt u de verzameling vergrendelen tijdens de gehele inventarisatie. Als u wilt toestaan dat de verzameling toegankelijk is voor meerdere threads voor lezen en schrijven, moet u uw eigen synchronisatie implementeren.

Standaard implementaties van verzamelingen in de System.Collections.Generic naamruimte worden niet gesynchroniseerd.

Notities voor uitvoerders

Voor het implementeren van deze interface moet de niet-generische IEnumerator interface worden geïmplementeerd. De MoveNext() en Reset() methoden zijn niet afhankelijk van Ten worden alleen weergegeven op de niet-generische interface. De Current eigenschap wordt weergegeven op beide interfaces en heeft verschillende retourtypen. Implementeer de eigenschap nongeneric Current als een expliciete interface-implementatie. Hierdoor kan elke consument van de niet-generische interface de algemene interface gebruiken.

Daarnaast IEnumerator<T> implementeert IDisposableu , waarvoor u de Dispose() methode moet implementeren. Hierdoor kunt u databaseverbindingen sluiten of bestandsingangen vrijgeven of vergelijkbare bewerkingen uitvoeren wanneer u andere resources gebruikt. Als er geen extra resources beschikbaar zijn om te verwijderen, moet u een lege Dispose() implementatie opgeven.

Zie ook

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