IOrderedDictionary Interfaz

Definición

Espacio de nombres:

System.Collections.Specialized

Ensamblado:

System.Collections.Specialized.dll

Representa una colección indizada de pares de clave y valor.

C#

public interface IOrderedDictionary : System.Collections.IDictionary

Derivado

System.Collections.Specialized.OrderedDictionary

Implementaciones

ICollection IDictionary IEnumerable

Ejemplos

En el ejemplo de código siguiente se muestra la implementación de una clase simple IOrderedDictionary basada en la ArrayList clase . El implementado IOrderedDictionary almacena los nombres de los nombres como claves y apellidos como valores, con el requisito agregado de que cada nombre es único.

C#

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

Comentarios

IOrderedDictionary Se puede acceder a los elementos con la clave o con el índice.

Cada elemento es un par clave-valor almacenado en una DictionaryEntry estructura.

Cada par debe tener una clave única que no nullsea , pero el valor puede ser null y no tiene que ser único. La IOrderedDictionary interfaz permite enumerar las claves y los valores contenidos, pero no implica ningún criterio de ordenación determinado.

La foreach instrucción del lenguaje C# (For Each en Visual Basic) devuelve un objeto del tipo de los elementos de la colección. Dado que cada elemento de IDictionary es un par clave-valor, el tipo de elemento no es el tipo de la clave o el tipo del valor. En su lugar, el tipo de elemento es DictionaryEntry, como se muestra en el ejemplo siguiente.

C#

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

La foreach instrucción es un contenedor alrededor del enumerador, que solo permite leer, no escribir en, la colección.

Notas a los implementadores

La clase de implementación debe tener un medio para comparar claves.

Propiedades

Count	Obtiene el número de elementos incluidos en ICollection. (Heredado de ICollection)
IsFixedSize	Obtiene un valor que indica si el objeto IDictionary tiene un tamaño fijo. (Heredado de IDictionary)
IsReadOnly	Obtiene un valor que indica si el objeto IDictionary es de solo lectura. (Heredado de IDictionary)
IsSynchronized	Obtiene un valor que indica si el acceso a la interfaz ICollection está sincronizado (es seguro para subprocesos). (Heredado de ICollection)
Item[Int32]	Obtiene o establece el elemento en el índice especificado.
Item[Object]	Obtiene o establece el elemento con la clave especificada. (Heredado de IDictionary)
Keys	Obtiene un objeto ICollection que contiene las claves del objeto IDictionary. (Heredado de IDictionary)
SyncRoot	Obtiene un objeto que se puede usar para sincronizar el acceso a ICollection. (Heredado de ICollection)
Values	Obtiene un objeto ICollection que contiene los valores del objeto IDictionary. (Heredado de IDictionary)

Métodos

Add(Object, Object)	Agrega un elemento con la clave y el valor proporcionados al objeto IDictionary. (Heredado de IDictionary)
Clear()	Quita todos los elementos del objeto IDictionary. (Heredado de IDictionary)
Contains(Object)	Determina si el objeto IDictionary contiene un elemento con la clave especificada. (Heredado de IDictionary)
CopyTo(Array, Int32)	Copia los elementos de ICollection en Array, empezando por un índice determinado de Array. (Heredado de ICollection)
GetEnumerator()	Devuelve un enumerador que itera por la colección IOrderedDictionary.
Insert(Int32, Object, Object)	Inserta un par de clave y valor en la colección, en el índice especificado.
Remove(Object)	Quita el elemento con la clave especificada del objeto IDictionary. (Heredado de IDictionary)
RemoveAt(Int32)	Quita el elemento en el índice especificado.

Métodos de extensión

Cast<TResult>(IEnumerable)	Convierte los elementos de IEnumerable en el tipo especificado.
OfType<TResult>(IEnumerable)	Filtra los elementos de IEnumerable en función de un tipo especificado.
AsParallel(IEnumerable)	Habilita la paralelización de una consulta.
AsQueryable(IEnumerable)	Convierte una interfaz IEnumerable en IQueryable.

Se aplica a

Consulte también

• ICollection
• IDictionary