Compartir vía

IEnumerator<T> Interfaz

  • Referencia

Definición

Espacio de nombres:
System.Collections.Generic
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Admite una iteración simple sobre una colección genérica.

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

Parámetros de tipo

T

Tipo de objetos que se van a enumerar.

Este parámetro de tipo es covariante, es decir, puede usar el tipo que haya especificado o cualquier tipo más derivado. Si desea obtener más información sobre la covarianza y la contravarianza, consulte Covarianza y contravarianza en genéricos.
Derivado
Implementaciones
IEnumerator IDisposable

Ejemplos

En el ejemplo siguiente se muestra una implementación de la interfaz IEnumerator<T> para una clase de colección de objetos personalizados. El objeto personalizado es una instancia del tipo Boxy la clase de colección es BoxCollection. Este ejemplo de código forma parte de un ejemplo más grande proporcionado para la interfaz 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

Comentarios

IEnumerator<T> es la interfaz base para todos los enumeradores genéricos.

La instrucción foreach del lenguaje C# (for each en C++, For Each en Visual Basic) oculta la complejidad de los enumeradores. Por lo tanto, se recomienda usar foreach, en lugar de manipular directamente el enumerador.

Los enumeradores se pueden usar para leer los datos de la colección, pero no se pueden usar para modificar la colección subyacente.

Inicialmente, el enumerador se coloca antes del primer elemento de la colección. En esta posición, Current no está definido. Por lo tanto, debe llamar a MoveNext para avanzar el enumerador al primer elemento de la colección antes de leer el valor de Current.

Current devuelve el mismo objeto hasta que se llama a MoveNext. MoveNext establece Current en el elemento siguiente.

Si MoveNext pasa el final de la colección, el enumerador se coloca después del último elemento de la colección y MoveNext devuelve false. Cuando el enumerador está en esta posición, las llamadas posteriores a MoveNext también devuelven false. Si la última llamada a MoveNext devuelve false, Current no está definida. No se puede establecer Current en el primer elemento de la colección de nuevo; En su lugar, debe crear una nueva instancia del enumerador.

El método Reset se proporciona para la interoperabilidad COM. No es necesario implementar necesariamente; en su lugar, el implementador simplemente puede iniciar un NotSupportedException. Sin embargo, si decide hacerlo, debe asegurarse de que ningún llamador se basa en la funcionalidad de Reset.

Si se realizan cambios en la colección, como agregar, modificar o eliminar elementos, el comportamiento del enumerador no está definido.

El enumerador no tiene acceso exclusivo a la colección; por lo tanto, la enumeración a través de una colección no es intrínsecamente un procedimiento seguro para subprocesos. Para garantizar la seguridad de los subprocesos durante la enumeración, puede bloquear la colección durante toda la enumeración. Para permitir que varios subprocesos puedan acceder a la colección para leer y escribir, debe implementar su propia sincronización.

Las implementaciones predeterminadas de colecciones del espacio de nombres System.Collections.Generic no se sincronizan.

Notas a los implementadores

La implementación de esta interfaz requiere la implementación de la interfaz de IEnumerator no genérico. Los métodos MoveNext() y Reset() no dependen de Ty solo aparecen en la interfaz no genérica. La propiedad Current aparece en ambas interfaces y tiene tipos de valor devuelto diferentes. Implemente la propiedad Current no genérico como una implementación de interfaz explícita. Esto permite que cualquier consumidor de la interfaz no genérica consuma la interfaz genérica.

Además, IEnumerator<T> implementa IDisposable, que requiere que implemente el método Dispose(). Esto le permite cerrar las conexiones de base de datos o liberar identificadores de archivo o operaciones similares al usar otros recursos. Si no hay recursos adicionales para eliminar, proporcione una implementación de Dispose() vacía.

Propiedades

Current

Obtiene el elemento de la colección en la posición actual del enumerador.

Métodos

Dispose()

Realiza tareas definidas por la aplicación asociadas a la liberación, liberación o restablecimiento de recursos no administrados.

(Heredado de IDisposable)
MoveNext()

Desplaza el enumerador al siguiente elemento de la colección.

(Heredado de IEnumerator)
Reset()

Establece el enumerador en su posición inicial, que es antes del primer elemento de la colección.

(Heredado de IEnumerator)

Se aplica a

Consulte también