Ler em inglês

Partilhar via


IOrderedDictionary Interface

Definição

Representa uma coleção indexada de pares chave/valor.

public interface IOrderedDictionary : System.Collections.IDictionary
Derivado
Implementações

Exemplos

O exemplo de código a seguir demonstra a implementação de um simples IOrderedDictionary com base na ArrayList classe . O implementado IOrderedDictionary armazena os nomes como as chaves e sobrenomes como os valores, com o requisito adicional de que cada nome seja exclusivo.

using System;
using System.Collections;
using System.Collections.Specialized;

public class People : IOrderedDictionary
{
    private ArrayList _people;

    public People(int numItems)
    {
        _people = new ArrayList(numItems);
    }

    public int IndexOfKey(object key)
    {
        for (int i = 0; i < _people.Count; i++)
        {
            if (((DictionaryEntry)_people[i]).Key == key)
                return i;
        }

        // key not found, return -1.
        return -1;
    }

    public object this[object key]
    {
        get
        {
            return ((DictionaryEntry)_people[IndexOfKey(key)]).Value;
        }
        set
        {
            _people[IndexOfKey(key)] = new DictionaryEntry(key, value);
        }
    }

    // IOrderedDictionary Members
    public IDictionaryEnumerator GetEnumerator()
    {
        return new PeopleEnum(_people);
    }

    public void Insert(int index, object key, object value)
    {
        if (IndexOfKey(key) != -1)
        {
            throw new ArgumentException("An element with the same key already exists in the collection.");
        }
        _people.Insert(index, new DictionaryEntry(key, value));
    }

    public void RemoveAt(int index)
    {
        _people.RemoveAt(index);
    }

    public object this[int index]
    {
        get
        {
            return ((DictionaryEntry)_people[index]).Value;
        }
        set
        {
            object key = ((DictionaryEntry)_people[index]).Key;
            _people[index] = new DictionaryEntry(key, value);
        }
    }
    // IDictionary Members

    public void Add(object key, object value)
    {
        if (IndexOfKey(key) != -1)
        {
            throw new ArgumentException("An element with the same key already exists in the collection.");
        }
        _people.Add(new DictionaryEntry(key, value));
    }

    public void Clear()
    {
        _people.Clear();
    }

    public bool Contains(object key)
    {
        if (IndexOfKey(key) == -1)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

    public bool IsFixedSize
    {
        get
        {
            return false;
        }
    }

    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    public ICollection Keys
    {
        get
        {
            ArrayList KeyCollection = new ArrayList(_people.Count);
            for (int i = 0; i < _people.Count; i++)
            {
                KeyCollection.Add( ((DictionaryEntry)_people[i]).Key );
            }
            return KeyCollection;
        }
    }

    public void Remove(object key)
    {
        _people.RemoveAt(IndexOfKey(key));
    }

    public ICollection Values
    {
        get
        {
            ArrayList ValueCollection = new ArrayList(_people.Count);
            for (int i = 0; i < _people.Count; i++)
            {
                ValueCollection.Add( ((DictionaryEntry)_people[i]).Value );
            }
            return ValueCollection;
        }
    }

    // ICollection Members

    public void CopyTo(Array array, int index)
    {
        _people.CopyTo(array, index);
    }

    public int Count
    {
        get
        {
            return _people.Count;
        }
    }

    public bool IsSynchronized
    {
        get
        {
            return _people.IsSynchronized;
        }
    }

    public object SyncRoot
    {
        get
        {
            return _people.SyncRoot;
        }
    }

    // IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator()
    {
        return new PeopleEnum(_people);
    }
}

public class PeopleEnum : IDictionaryEnumerator
{
    public ArrayList _people;

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

    public PeopleEnum(ArrayList list)
    {
        _people = list;
    }

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

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

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

    public DictionaryEntry Entry
    {
        get
        {
            return (DictionaryEntry)Current;
        }
    }

    public object Key
    {
        get
        {
            try
            {
                return ((DictionaryEntry)_people[position]).Key;
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }

    public object Value
    {
        get
        {
            try
            {
                return ((DictionaryEntry)_people[position]).Value;
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }
}

class App
{
    static void Main()
    {
        People peopleCollection = new People(3);
        peopleCollection.Add("John", "Smith");
        peopleCollection.Add("Jim", "Johnson");
        peopleCollection.Add("Sue", "Rabon");

        Console.WriteLine("Displaying the entries in peopleCollection:");
        foreach (DictionaryEntry de in peopleCollection)
        {
            Console.WriteLine("{0} {1}", de.Key, de.Value);
        }

        Console.WriteLine();
        Console.WriteLine("Displaying the entries in the modified peopleCollection:");
        peopleCollection["Jim"] = "Jackson";
        peopleCollection.Remove("Sue");
        peopleCollection.Insert(0, "Fred", "Anderson");

        foreach (DictionaryEntry de in peopleCollection)
        {
            Console.WriteLine("{0} {1}", de.Key, de.Value);
        }
    }
}
/* This code produces output similar to the following:
 *
 * Displaying the entries in peopleCollection:
 * John Smith
 * Jim Johnson
 * Sue Rabon
 *
 * Displaying the entries in the modified peopleCollection:
 * Fred Anderson
 * John Smith
 * Jim Jackson
 */

Comentários

IOrderedDictionary os elementos podem ser acessados com a chave ou com o índice.

Cada elemento é um par chave/valor armazenado em uma DictionaryEntry estrutura.

Cada par deve ter uma chave exclusiva que não nullseja , mas o valor pode ser null e não precisa ser exclusivo. A IOrderedDictionary interface permite que as chaves e os valores contidos sejam enumerados, mas não implica nenhuma ordem de classificação específica.

A foreach instrução da linguagem C# (For Each no Visual Basic) retorna um objeto do tipo dos elementos na coleção. Como cada elemento do IDictionary é um par chave/valor, o tipo de elemento não é o tipo da chave ou o tipo do valor. Em vez disso, o tipo de elemento é DictionaryEntry, como mostra o exemplo a seguir.

foreach (DictionaryEntry de in myOrderedDictionary)
{
    //...
}

A foreach instrução é um wrapper ao redor do enumerador, que permite apenas a leitura, não a gravação na coleção.

Notas aos Implementadores

A classe de implementação deve ter um meio de comparar chaves.

Propriedades

Count

Obtém o número de elementos contidos no ICollection.

(Herdado de ICollection)
IsFixedSize

Obtém um valor que indica se o objeto IDictionary tem um tamanho fixo.

(Herdado de IDictionary)
IsReadOnly

Obtém um valor que indica se o objeto IDictionary é somente leitura.

(Herdado de IDictionary)
IsSynchronized

Obtém um valor que indica se o acesso à ICollection é sincronizado (thread-safe).

(Herdado de ICollection)
Item[Int32]

Obtém ou define o elemento no índice especificado.

Item[Object]

Obtém ou define o elemento com a chave especificada.

(Herdado de IDictionary)
Keys

Obtém um objeto ICollection que contém as chaves do objeto IDictionary.

(Herdado de IDictionary)
SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso ao ICollection.

(Herdado de ICollection)
Values

Obtém um objeto ICollection que contém os valores no objeto IDictionary.

(Herdado de IDictionary)

Métodos

Add(Object, Object)

Adiciona um elemento com a chave e o valor fornecidos ao objeto IDictionary.

(Herdado de IDictionary)
Clear()

Remove todos os elementos do objeto IDictionary.

(Herdado de IDictionary)
Contains(Object)

Determina se o objeto IDictionary contém um elemento com a chave especificada.

(Herdado de IDictionary)
CopyTo(Array, Int32)

Copia os elementos do ICollection para um Array, começando em um determinado índice Array.

(Herdado de ICollection)
GetEnumerator()

Retorna um enumerador que itera por meio da coleção IOrderedDictionary.

Insert(Int32, Object, Object)

Insere um par chave-valor na coleção no índice especificado.

Remove(Object)

Remove o elemento com a chave especificada do objeto IDictionary.

(Herdado de IDictionary)
RemoveAt(Int32)

Remove o elemento no índice especificado.

Métodos de Extensão

Cast<TResult>(IEnumerable)

Converte os elementos de um IEnumerable para o tipo especificado.

OfType<TResult>(IEnumerable)

Filtra os elementos de um IEnumerable com base em um tipo especificado.

AsParallel(IEnumerable)

Habilita a paralelização de uma consulta.

AsQueryable(IEnumerable)

Converte um IEnumerable em um IQueryable.

Aplica-se a

Produto Versões
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1
UWP 10.0

Confira também