Esta página foi útil?
Seus comentários sobre este conteúdo são importantes. Queremos saber sua opinião.
Comentários adicionais?
1500 caracteres restantes
Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Interface IDictionaryEnumerator

Enumera os elementos de um tipo Dictionary não-genérico.

Namespace:  System.Collections
Assembly:  mscorlib (em mscorlib.dll)

[ComVisibleAttribute(true)]
public interface IDictionaryEnumerator : IEnumerator

O tipo IDictionaryEnumerator expõe os membros a seguir.

  NomeDescrição
Propriedade públicaCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreCurrentObtém o elemento atual na coleção. (Herdado de IEnumerator.)
Propriedade públicaCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreEntryObtém a chave e o valor da entrada do dicionário atual.
Propriedade públicaCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreKeyObtém a chave da entrada do dicionário atual.
Propriedade públicaCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreValueObtém o valor da entrada do dicionário atual.
Superior

  NomeDescrição
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreMoveNextAvança o enumerador para o próximo elemento da coleção. (Herdado de IEnumerator.)
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreResetDefine o enumerador como sua posição inicial, que é antes do primeiro elemento da coleção. (Herdado de IEnumerator.)
Superior

[Visual Basic, C#]

O foreach a instrução do idioma C# (for each em Visual Basic) oculta a complexidade dos enumeradores. Portanto, o uso foreach é recomendado em vez de manipular diretamente o enumerador.

Enumeradores podem ser usados para ler os dados na coleção, mas eles não podem ser usados para modificar a coleção subjacente.

Inicialmente, o enumerador está posicionado antes do primeiro elemento na coleção. O Reset método também traz o enumerador voltar para essa posição. AT isso posicionar, chamando o Current propriedade lança uma exceção. Portanto, você deve chamar o MoveNext método para avançar o enumerador para o primeiro elemento da coleção antes de ler o valor de Current.

Current Retorna o mesmo objeto até MoveNext ou Reset é chamado. MoveNext define Current para o próximo elemento.

Se MoveNext passa o final da coleção, o enumerador está posicionado após o último elemento na coleção e MoveNext retorna false. Quando o enumerador está nessa posição, chamadas subseqüentes para MoveNext também retornará false. Se a última chamada para MoveNext retornou false, chamada Current lança uma exceção. Para definir Current para o primeiro elemento da coleção novamente, você pode chamar Reset seguido de MoveNext.

Um enumerador permanece válido, desde que a coleção permaneça inalterada. Se houver alterações à coleção, tais como adicionar, modificar, ou excluir elementos, o enumerador é irrecoverably invalidado e a próxima chamada para MoveNext ou Reset lança um InvalidOperationException. Se a coleção é modificada entre MoveNext e Current, Current retorna o elemento que ele está definido, mesmo se o enumerador já é invalidado.

O enumerador não tem acesso exclusivo à coleção; Portanto, enumerando através de uma coleção intrinsecamente não um procedimento de segmento-seguro. Mesmo quando uma coleção é sincronizada, outros Threads poderá ainda modificar a coleção, que faz com que o enumerador para gerar uma exceção. Para garantir segurança de segmentos durante enumeração, você pode bloquear a coleção durante a enumeração inteira ou pegar as exceções resultantes de alterações feitas por outros segmentos.

Observações para implementadores

O Current propriedade herdada do IEnumerator retorna um Object ou seja um in a box DictionaryEntry, semelhante ao que o valor de retorno a Entry propriedade.

Este exemplo de código mostra como definir um enumerador de dicionário que implementa o IDictionaryEnumerator interface.


using System;
using System.Collections;

// This class implements a simple dictionary using an array of DictionaryEntry objects (key/value pairs).
public class SimpleDictionary : IDictionary
{
    // The array of items
    private DictionaryEntry[] items;
    private Int32 ItemsInUse = 0;

    // Construct the SimpleDictionary with the desired number of items.
    // The number of items cannot change for the life time of this SimpleDictionary.
    public SimpleDictionary(Int32 numItems)
    {
        items = new DictionaryEntry[numItems];
    }


    #region IDictionary Members
    public bool IsReadOnly { get { return false; } }
    public bool Contains(object key)
    {
       Int32 index;
       return TryGetIndexOfKey(key, out index);
    }
    public bool IsFixedSize { get { return false; } }
    public void Remove(object key)
    {
        if (key == null) throw new ArgumentNullException("key");
        // Try to find the key in the DictionaryEntry array
        Int32 index;
        if (TryGetIndexOfKey(key, out index))
        {
            // If the key is found, slide all the items up.
            Array.Copy(items, index + 1, items, index, ItemsInUse - index - 1);
            ItemsInUse--;
        } 
        else
        {
            // If the key is not in the dictionary, just return. 
        }
    }
    public void Clear() { ItemsInUse = 0; }
    public void Add(object key, object value) 
    {
        // Add the new key/value pair even if this key already exists in the dictionary.
        if (ItemsInUse == items.Length)
            throw new InvalidOperationException("The dictionary cannot hold any more items.");
        items[ItemsInUse++] = new DictionaryEntry(key, value);
    }
    public ICollection Keys
    {
        get
        {
            // Return an array where each item is a key.
            Object[] keys = new Object[ItemsInUse];
            for (Int32 n = 0; n < ItemsInUse; n++)
                keys[n] = items[n].Key;
            return keys;
        }
    }
    public ICollection Values
    {
        get
        {
            // Return an array where each item is a value.
            Object[] values = new Object[ItemsInUse];
            for (Int32 n = 0; n < ItemsInUse; n++)
                values[n] = items[n].Value;
            return values;
        }
    }
    public object this[object key]
    {
        get
        {   
            // If this key is in the dictionary, return its value.
            Int32 index;
            if (TryGetIndexOfKey(key, out index))
            {
                // The key was found; return its value.
                return items[index].Value;
            } 
            else
            {
                // The key was not found; return null.
                return null;
            }
        }

        set
        {
            // If this key is in the dictionary, change its value. 
            Int32 index;
            if (TryGetIndexOfKey(key, out index))
            {
                // The key was found; change its value.
                items[index].Value = value;
            } 
            else
            {
                // This key is not in the dictionary; add this key/value pair.
                Add(key, value);
            }
        }
    }
    private Boolean TryGetIndexOfKey(Object key, out Int32 index)
    {
        for (index = 0; index < ItemsInUse; index++)
        {
            // If the key is found, return true (the index is also returned).
            if (items[index].Key.Equals(key)) return true;
        }

        // Key not found, return false (index should be ignored by the caller).
        return false;
    }
    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
}

public sealed class App
{
    static void Main()
    {
        // Create a dictionary that contains no more than three entries.
        IDictionary d = new SimpleDictionary(3);

        // Add three people and their ages to the dictionary.
        d.Add("Jeff", 40);
        d.Add("Kristin", 34);
        d.Add("Aidan", 1);

        Console.WriteLine("Number of elements in dictionary = {0}", d.Count);

        Console.WriteLine("Does dictionary contain 'Jeff'? {0}", d.Contains("Jeff"));
        Console.WriteLine("Jeff's age is {0}", d["Jeff"]);

        // Display every entry's key and value.
        foreach (DictionaryEntry de in d)
        {
            Console.WriteLine("{0} is {1} years old.", de.Key, de.Value);
        }

        // Remove an entry that exists.
        d.Remove("Jeff");

        // Remove an entry that does not exist, but do not throw an exception.
        d.Remove("Max");

        // Show the names (keys) of the people in the dictionary.
        foreach (String s in d.Keys)
            Console.WriteLine(s);

        // Show the ages (values) of the people in the dictionary.
        foreach (Int32 age in d.Values)
            Console.WriteLine(age);
    }
}

// This code produces the following output.
//
// Number of elements in dictionary = 3
// Does dictionary contain 'Jeff'? True
// Jeff's age is 40
// Jeff is 40 years old.
// Kristin is 34 years old.
// Aidan is 1 years old.
// Kristin
// Aidan
// 34
// 1


.NET Framework

Com suporte em: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Biblioteca de Classes Portátil

Com suporte em: Biblioteca de Classes Portátil

.NET para aplicativos da Windows Store

Com suporte em: Windows 8

.NET para aplicativos do Windows Phone

Com suporte em: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2015 Microsoft