Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Interfaz IDictionary

 

Publicado: octubre de 2016

Representa una colección no genérica de pares clave-valor.

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

[ComVisibleAttribute(true)]
public interface IDictionary : ICollection, IEnumerable

NombreDescripción
System_CAPS_pubpropertyCount

Obtiene el número de elementos incluidos en ICollection.(Heredado de ICollection).

System_CAPS_pubpropertyIsFixedSize

Obtiene un valor que indica si el objeto IDictionary tiene un tamaño fijo.

System_CAPS_pubpropertyIsReadOnly

Obtiene un valor que indica si el objeto IDictionary es de solo lectura.

System_CAPS_pubpropertyIsSynchronized

Obtiene un valor que indica si el acceso a la interfaz ICollection está sincronizado (es seguro para subprocesos).(Heredado de ICollection).

System_CAPS_pubpropertyItem[Object]

Obtiene o establece el elemento con la clave especificada.

System_CAPS_pubpropertyKeys

Obtiene un objeto ICollection que contiene las claves del objeto IDictionary.

System_CAPS_pubpropertySyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a ICollection.(Heredado de ICollection).

System_CAPS_pubpropertyValues

Obtiene un objeto ICollection que contiene los valores del objeto IDictionary.

NombreDescripción
System_CAPS_pubmethodAdd(Object, Object)

Agrega un elemento con la clave y el valor proporcionados al objeto IDictionary.

System_CAPS_pubmethodClear()

Quita todos los elementos del objeto IDictionary.

System_CAPS_pubmethodContains(Object)

Determina si el objeto IDictionary contiene un elemento con la clave especificada.

System_CAPS_pubmethodCopyTo(Array, Int32)

Copia los elementos de ICollection en Array, empezando por un índice determinado de Array.(Heredado de ICollection).

System_CAPS_pubmethodGetEnumerator()

Devuelve un objeto IDictionaryEnumerator para el objeto IDictionary.

System_CAPS_pubmethodRemove(Object)

Quita el elemento con la clave especificada del objeto IDictionary.

NombreDescripción
System_CAPS_pubmethodAsParallel()

Sobrecargado. Habilita la paralelización de una consulta.(Definido por ParallelEnumerable).

System_CAPS_pubmethodAsQueryable()

Sobrecargado. Convierte un IEnumerable para un IQueryable.(Definido por Queryable).

System_CAPS_pubmethodCast<TResult>()

Convierte los elementos de un IEnumerable al tipo especificado.(Definido por Enumerable).

System_CAPS_pubmethodOfType<TResult>()

Filtra los elementos de un IEnumerable basado en un tipo especificado.(Definido por Enumerable).

El IDictionary es la interfaz base para las colecciones no genéricas de pares clave/valor. Para obtener la versión genérica de esta interfaz, vea System.Collections.Generic.IDictionary<TKey, TValue>.

Cada elemento es un par de clave y valor almacenado en un DictionaryEntry objeto.

Cada par debe tener una clave única. Las implementaciones pueden variar en si permiten que la clave es null. El valor puede ser null y no tienen que ser únicos. El IDictionary interfaz permite las claves y valores incluidos enumerar, pero no implica un criterio de ordenación concreto.

IDictionary las implementaciones se dividen en tres categorías: sólo lectura, tamaño fijo, de tamaño variable. Sólo lectura IDictionary no se puede modificar el objeto. Un tamaño fijo IDictionary objeto no admite la adición o eliminación de elementos, pero permite la modificación de los elementos existentes. Un tamaño variable IDictionary objeto permite agregar, quitar y modificar elementos.

El foreach instrucción del lenguaje C# (For Each en Visual Basic) devuelve un objeto del tipo de los elementos de la colección. Puesto que cada elemento de la IDictionary objeto 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. Por ejemplo:

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

El foreach instrucción es un contenedor del enumerador, que permite solo lectura, pero no escribir en la colección.

Notas para implementadores:

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

En el ejemplo de código siguiente se muestra cómo definir una clase de diccionario simple que implementa el IDictionary interfaz.

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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: