Esta documentación está archivada y no tiene mantenimiento.

IDictionaryEnumerator (Interfaz)

Enumera los elementos de un diccionario no genérico.

Espacio de nombres: System.Collections
Ensamblado: mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)] 
public interface IDictionaryEnumerator : IEnumerator
/** @attribute ComVisibleAttribute(true) */ 
public interface IDictionaryEnumerator extends IEnumerator
ComVisibleAttribute(true) 
public interface IDictionaryEnumerator extends IEnumerator

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

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

Inicialmente, el enumerador se coloca delante del primer elemento de la colección. El método Reset también devuelve el enumerador a esta posición. En esta posición, una llamada a la propiedad Current inicia una excepción. Por lo tanto, se debe llamar al método MoveNext para desplazar el enumerador hasta el primer elemento de la colección antes de leer el valor de Current.

Current devuelve el mismo objeto hasta que se llama al método MoveNext o Reset. MoveNext establece el valor de la propiedad Current en el siguiente elemento.

Si MoveNext pasa el final de la colección, el enumerador se coloca detrás del último elemento de la colección y MoveNext devuelve false. Cuando el enumerador está en esta posición, las llamadas posteriores al método MoveNext también devuelven el valor false. Si la última llamada al método MoveNext ha devuelto false y se realiza una llamada a la propiedad Current, se produce una excepción. Para volver a establecer el valor de Current en el primer elemento de la colección, se puede llamar primero al método Reset y después al método MoveNext.

Un enumerador sigue siendo válido mientras la colección no cambie. Si se realizan cambios en la colección, como agregar, modificar o eliminar elementos, el enumerador se invalida definitivamente y la siguiente llamada a MoveNext o a Reset produce una excepción InvalidOperationException. Si la colección se modifica entre MoveNext y Current, la propiedad Current devuelve el elemento en el que está establecida, aunque el enumerador ya haya quedado invalidado.

El enumerador no tiene acceso exclusivo a la colección; por lo tanto, la enumeración a través de una colección es un procedimiento que, en esencia, no es seguro para la ejecución de subprocesos. Aunque una colección esté sincronizada, otros subprocesos pueden seguir modificándola, por lo que el enumerador produce una excepción. Con el fin de garantizar la seguridad para la ejecución de subprocesos durante la enumeración, se puede bloquear la colección durante toda la enumeración o detectar las excepciones debidas a cambios efectuados por otros subprocesos.

Notas para los implementadores La propiedad Current que se hereda de IEnumerator devuelve un Object, que es una estructura DictionaryEntry a la que se ha aplicado la conversión boxing, similar al valor que devuelve la propiedad Entry.

En este ejemplo de código se muestra cómo definir un enumerador de diccionario que implementa la interfaz IDictionaryEnumerator.

    private class SimpleDictionaryEnumerator : IDictionaryEnumerator
    {
        // A copy of the SimpleDictionary object's key/value pairs.
        DictionaryEntry[] items;
        Int32 index = -1;

        public SimpleDictionaryEnumerator(SimpleDictionary sd)
        {
            // Make a copy of the dictionary entries currently in the SimpleDictionary object.
            items = new DictionaryEntry[sd.Count];
            Array.Copy(sd.items, 0, items, 0, sd.Count);
        }

        // Return the current item.
        public Object Current { get { ValidateIndex(); return items[index]; } }

        // Return the current dictionary entry.
        public DictionaryEntry Entry
        {
            get { return (DictionaryEntry) Current; }
        }

        // Return the key of the current item.
        public Object Key { get { ValidateIndex();  return items[index].Key; } }

        // Return the value of the current item.
        public Object Value { get { ValidateIndex();  return items[index].Value; } }

        // Advance to the next item.
        public Boolean MoveNext()
        {
            if (index < items.Length - 1) { index++; return true; }
            return false;
        }

        // Validate the enumeration index and throw an exception if the index is out of range.
        private void ValidateIndex()
        {
            if (index < 0 || index >= items.Length)
            throw new InvalidOperationException("Enumerator is before or after the collection.");
        }

        // Reset the index to restart the enumeration.
        public void Reset()
        {
            index = -1;
        }
    }
    public IDictionaryEnumerator GetEnumerator()
    {
        // Construct and return an enumerator.
        return new SimpleDictionaryEnumerator(this);
    }
    #endregion

    #region ICollection Members
    public bool IsSynchronized { get { return false; } }
    public object SyncRoot { get { throw new NotImplementedException(); } }
    public int Count { get { return ItemsInUse; } }
    public void CopyTo(Array array, int index) { throw new NotImplementedException(); }
    #endregion

    #region IEnumerable Members
    IEnumerator IEnumerable.GetEnumerator() 
    {
        // Construct and return an enumerator.
        return ((IDictionary)this).GetEnumerator();
    }
    #endregion
}

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0
Mostrar: