IDictionary Schnittstelle
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

IDictionary-Schnittstelle

 

Stellt eine nicht generische Auflistung von Schlüssel-Wert-Paaren dar.

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

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

NameBeschreibung
System_CAPS_pubpropertyCount

Ruft die Anzahl der Elemente ab, die in ICollection enthalten sind.(Geerbt von ICollection.)

System_CAPS_pubpropertyIsFixedSize

Ruft einen Wert ab, der angibt, ob das IDictionary-Objekt eine feste Größe hat.

System_CAPS_pubpropertyIsReadOnly

Ruft einen Wert ab, der angibt, ob das IDictionary schreibgeschützt ist.

System_CAPS_pubpropertyIsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die ICollection synchronisiert (threadsicher) ist.(Geerbt von ICollection.)

System_CAPS_pubpropertyItem[Object]

Ruft das Element mit dem angegebenen Schlüssel ab oder legt dieses fest.

System_CAPS_pubpropertyKeys

Ruft ein ICollection-Objekt ab, das die Schlüssel des IDictionary-Objekts enthält.

System_CAPS_pubpropertySyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf ICollection synchronisiert werden kann.(Geerbt von ICollection.)

System_CAPS_pubpropertyValues

Ruft ein ICollection-Objekt ab, das die Werte des IDictionary-Objekts enthält.

NameBeschreibung
System_CAPS_pubmethodAdd(Object, Object)

Fügt dem IDictionary-Objekt ein Element mit dem angegebenen Schlüssel und Wert hinzu.

System_CAPS_pubmethodClear()

Entfernt alle Elemente aus dem IDictionary-Objekt.

System_CAPS_pubmethodContains(Object)

Ermittelt, ob das IDictionary-Objekt ein Element mit dem angegebenen Schlüssel enthält.

System_CAPS_pubmethodCopyTo(Array, Int32)

Kopiert die Elemente der ICollection in ein Array, beginnend bei einem bestimmten Array-Index.(Geerbt von ICollection.)

System_CAPS_pubmethodGetEnumerator()

Gibt ein IDictionaryEnumerator-Objekt für das IDictionary-Objekt zurück.

System_CAPS_pubmethodRemove(Object)

Entfernt das Element mit dem angegebenen Schlüssel aus dem IDictionary-Objekt.

NameBeschreibung
System_CAPS_pubmethodAsParallel()

Überladen. Ermöglicht die Parallelisierung einer Abfrage.(Definido por ParallelEnumerable).

System_CAPS_pubmethodAsQueryable()

Überladen. Konvertiert einen IEnumerable in einen IQueryable.(Definido por Queryable).

System_CAPS_pubmethodCast<TResult>()

Wandelt die Elemente eines IEnumerable in den angegebenen Typ um.(Definido por Enumerable).

System_CAPS_pubmethodOfType<TResult>()

Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs.(Definido por Enumerable).

Die IDictionary -Schnittstelle ist die Basisschnittstelle für nicht generische Auflistungen von Schlüssel-Wert-Paaren.Die generische Version dieser Schnittstelle finden Sie unter System.Collections.Generic.IDictionary<TKey, TValue>.

Jedes Element ist ein Schlüssel-Wert-Paar gespeichert, die einem DictionaryEntry Objekt.

Jedes Paar muss einen eindeutigen Schlüssel verfügen.Implementierungen können variieren, ob den Schlüssel null sein dürfen.Der Wert kann null sein und muss nicht eindeutig sein.Die IDictionary Schnittstelle ermöglicht die Schlüssel und Werte, gibt aber keine festgelegte Sortierreihenfolge.

IDictionary-Implementierungen werden in drei Kategorien unterteilt: schreibgeschützt, feste Größe und Variable Größe.Eine schreibgeschützte IDictionary Objekt kann nicht geändert werden.Ein fester Größe IDictionary Objekt lässt sich nicht auf das Hinzufügen oder Entfernen von Elementen, aber die Änderung von Elementen ermöglicht.Variabler Größe IDictionary Objekt ermöglicht das Hinzufügen, entfernen und Ändern von Elementen.

Die foreach -Anweisung in c# (For Each in Visual Basic) gibt ein Objekt des Typs der Elemente in der Auflistung zurück.Da jedes Element von der IDictionary Objekt ist ein Schlüssel/Wert-Paar, des Elementtyps nicht der Typ des Schlüssels oder des Wertes.Stattdessen wird der Typ des Elements DictionaryEntry. Zum Beispiel:

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

Die foreach -Anweisung ist ein Wrapper um den Enumerator, der nur das Lesen aus, jedoch nicht das Schreiben in der Auflistung zulässt.

Hinweise zur Implementierung:

Die implementierende Klasse muss ein Mittel zum Vergleichen von Schlüsseln verfügen.

Im folgenden Codebeispiel wird veranschaulicht, wie eine einfaches Dictionary-Klasse definiert wird, implementiert die IDictionary Schnittstelle.

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

Universal Windows Platform
Verfügbar seit 4.5
.NET Framework
Verfügbar seit 1.1
Portable Class Library
Unterstützt in: portable .NET platforms
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen:
© 2016 Microsoft