Freigeben über


IOrderedDictionary Schnittstelle

Definition

Stellt eine indizierte Auflistung der Schlüssel-Wert-Paare dar.

public interface class IOrderedDictionary : System::Collections::IDictionary
public interface IOrderedDictionary : System.Collections.IDictionary
type IOrderedDictionary = interface
    interface ICollection
    interface IEnumerable
    interface IDictionary
type IOrderedDictionary = interface
    interface IDictionary
    interface ICollection
    interface IEnumerable
Public Interface IOrderedDictionary
Implements IDictionary
Abgeleitet
Implementiert

Beispiele

Im folgenden Codebeispiel wird die Implementierung eines einfachen IOrderedDictionary basierend auf der ArrayList -Klasse veranschaulicht. Die implementierte IOrderedDictionary speichert Vornamen als Schlüssel und Nachnamen als Werte, mit der zusätzlichen Anforderung, dass jeder Vorname eindeutig ist.


#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;

public ref class PeopleEnum : IDictionaryEnumerator
{
private:
    // Enumerators are positioned before the first element
    // until the first MoveNext() call.
    int position;
    ArrayList^ _people;

public:
    PeopleEnum(ArrayList^ list)
    {
        this->Reset();
        _people = list;
    }

    virtual bool MoveNext()
    {
        position++;
        return (position < _people->Count);
    }

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

    virtual property Object^ Current
    {
        Object^ get()
        {
            try
            {
                return _people[position];
            }
            catch (IndexOutOfRangeException^)
            {
                throw gcnew InvalidOperationException();
            }
        }
    }

    virtual property DictionaryEntry Entry
    {
        DictionaryEntry get()
        {
            return (DictionaryEntry)(Current);
        }
    }

    virtual property Object^ Key
    {
        Object^ get()
        {
            try
            {
                return ((DictionaryEntry^)_people[position])->Key;
            }
            catch (IndexOutOfRangeException^)
            {
                throw gcnew InvalidOperationException();
            }
        }
    }

    virtual property Object^ Value
    {
        Object^ get()
        {
            try
            {
                return ((DictionaryEntry^)_people[position])->Value;
            }
            catch (IndexOutOfRangeException^)
            {
                throw gcnew InvalidOperationException();
            }
        }
    }
};

public ref class People : IOrderedDictionary
{
private:
    ArrayList^ _people;

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

    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;
    }

    virtual property Object^ default[Object^]
    {
        Object^ get(Object^ key)
        {
            return ((DictionaryEntry^)_people[IndexOfKey(key)])->Value;
        }
        void set(Object^ key, Object^ value)
        {
            _people[IndexOfKey(key)] = gcnew DictionaryEntry(key, value);
        }
    }

    // IOrderedDictionary Members
    virtual IDictionaryEnumerator^ GetEnumerator()
    {
        return gcnew PeopleEnum(_people);
    }

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

    virtual void RemoveAt(int index)
    {
        _people->RemoveAt(index);
    }

    virtual property Object^ default[int]
    {
        Object^ get(int index)
        {
            return ((DictionaryEntry^)_people[index])->Value;
        }
        void set(int index, Object^ value)
        {
            Object^ key = ((DictionaryEntry^)_people[index])->Key;
            _people[index] = gcnew DictionaryEntry(key, value);
        }
    }

    // IDictionary Members

    virtual void Add(Object^ key, Object^ value)
    {
        if (IndexOfKey(key) != -1)
        {
            throw gcnew ArgumentException("An element with the same key already exists in the collection.");
        }
        _people->Add(gcnew DictionaryEntry(key, value));
    }

    virtual void Clear()
    {
        _people->Clear();
    }

    virtual bool Contains(Object^ key)
    {
        if (IndexOfKey(key) == -1)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

    virtual property bool IsFixedSize
    {
        bool get()
        {
            return false;
        }
    }

    virtual property bool IsReadOnly
    {
        bool get()
        {
            return false;
        }
    }

    virtual property ICollection^ Keys
    {
        ICollection^ get()
        {
            ArrayList^ KeyCollection = gcnew ArrayList(_people->Count);
            for (int i = 0; i < _people->Count; i++)
            {
                KeyCollection->Add( ((DictionaryEntry^)_people[i])->Key );
            }
            return KeyCollection;
        }
    }

    virtual void Remove(Object^ key)
    {
        _people->RemoveAt(IndexOfKey(key));
    }

    virtual property ICollection^ Values
    {
        ICollection ^get()
        {
            ArrayList^ ValueCollection = gcnew ArrayList(_people->Count);
            for (int i = 0; i < _people->Count; i++)
            {
                ValueCollection->Add( ((DictionaryEntry^)_people[i])->Value );
            }
            return ValueCollection;
        }
    }

    // ICollection Members

    virtual void CopyTo(Array^ array, int index)
    {
        _people->CopyTo(array, index);
    }

    virtual property int Count
    {
        int get()
        {
            return _people->Count;
        }
    }

    virtual property bool IsSynchronized
    {
        bool get()
        {
            return _people->IsSynchronized;
        }
    }

    virtual property Object^ SyncRoot
    {
        Object^ get()
        {
            return _people->SyncRoot;
        }
    }

    // IEnumerable Members

    virtual IEnumerator^ IfcGetEnumerator() = IEnumerable::GetEnumerator
    {
        return (IEnumerator^) gcnew PeopleEnum(_people);
    }
};

class App
{
public:
    static void Main()
    {
        People^ peopleCollection = gcnew People(3);
        peopleCollection->Add("John", "Smith");
        peopleCollection->Add("Jim", "Johnson");
        peopleCollection->Add("Sue", "Rabon");

        Console::WriteLine("Displaying the entries in peopleCollection:");
        for each (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");

        for each (DictionaryEntry^ de in peopleCollection)
        {
            Console::WriteLine("{0} {1}", de->Key, de->Value);
        }

    }
};

int main()
{
    App::Main();
}
/* 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
 */
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
 */
Imports System.Collections
Imports System.Collections.Specialized

Public Class People
    Implements IOrderedDictionary
    Private _people As ArrayList

    Public Sub New(ByVal numItems As Integer)
        _people = New ArrayList(numItems)
    End Sub

    Public Function IndexOfKey(ByVal key As Object) As Integer
        Dim i As Integer
        For i = 0 To _people.Count - 1
            If CType(_people(i), DictionaryEntry).Key = key Then
                Return i
            End If
        Next i

        ' key not found, return -1.
        Return -1
    End Function

    ' IOrderedDictionary Members
    Public Function GetEnumerator() As IDictionaryEnumerator _
        Implements IOrderedDictionary.GetEnumerator

        Return New PeopleEnum(_people)
    End Function

    Public Sub Insert(ByVal index As Integer, ByVal key As Object, _
        ByVal value As Object) Implements IOrderedDictionary.Insert

        If Not IndexOfKey(key) = -1 Then
            Throw New ArgumentException("An element with the same key already exists in the collection.")
        End If
        _people.Insert(index, New DictionaryEntry(key, value))
    End Sub

    Public Sub RemoveAt(ByVal index As Integer) _
        Implements IOrderedDictionary.RemoveAt

        _people.RemoveAt(index)
    End Sub

    Public Property Item(ByVal index As Integer) As Object _
        Implements IOrderedDictionary.Item

        Get
            Return CType(_people(index), DictionaryEntry).Value
        End Get
        Set(ByVal value As Object)
            Dim key As Object = CType(_people(index), DictionaryEntry).Key
            _people(index) = New DictionaryEntry(key, value)
        End Set
    End Property

    ' IDictionary Members
    Public Function IDictionaryGetEnumerator() As IDictionaryEnumerator _
    Implements IDictionary.GetEnumerator

        Return New PeopleEnum(_people)
    End Function

    Public Property Item(ByVal key As Object) As Object _
        Implements IDictionary.Item

        Get
            Return CType(_people(IndexOfKey(key)), DictionaryEntry).Value
        End Get
        Set(ByVal value)
            _people(IndexOfKey(key)) = New DictionaryEntry(key, value)
        End Set
    End Property


    Public Sub Add(ByVal key As Object, ByVal value As Object) _
        Implements IDictionary.Add

        If Not IndexOfKey(key) = -1 Then
            Throw New ArgumentException("An element with the same key already exists in the collection.")
        End If

        _people.Add(New DictionaryEntry(key, value))
    End Sub

    Public Sub Clear() Implements IDictionary.Clear
        _people.Clear()
    End Sub

    Public Function Contains(ByVal key As Object) As Boolean _
        Implements IDictionary.Contains

        If IndexOfKey(key) = -1 Then
            Return False
        Else
            Return True
        End If
    End Function

    Public ReadOnly Property IsFixedSize() As Boolean _
        Implements IDictionary.IsFixedSize

        Get
            Return False
        End Get
    End Property

    Public ReadOnly Property IsReadOnly() As Boolean _
        Implements IDictionary.IsReadOnly
        Get
            Return False
        End Get
    End Property

    Public ReadOnly Property Keys() As ICollection _
        Implements IDictionary.Keys
        Get
            Dim KeyCollection As ArrayList = New ArrayList(_people.Count)
            Dim i As Integer
            For i = 0 To _people.Count - 1
                KeyCollection.Add( CType(_people(i), DictionaryEntry).Key )
            Next i
            Return KeyCollection
        End Get
    End Property

    Public Sub Remove(ByVal key As Object) _
        Implements IDictionary.Remove

        _people.RemoveAt(IndexOfKey(key))
    End Sub

    Public ReadOnly Property Values() As ICollection _
        Implements IDictionary.Values
        Get
            Dim ValueCollection As ArrayList = New ArrayList(_people.Count)
            Dim i As Integer
            For i = 0 To _people.Count - 1
                ValueCollection.Add( CType(_people(i), DictionaryEntry).Value )
            Next i
            Return ValueCollection
        End Get
    End Property

    ' ICollection Members
    Public Sub CopyTo(ByVal array As Array, ByVal index As Integer) _
    Implements ICollection.CopyTo

        _people.CopyTo(Array, index)
    End Sub

    Public ReadOnly Property Count() As Integer _
        Implements ICollection.Count

        Get
            Return _people.Count
        End Get
    End Property

    Public ReadOnly Property IsSynchronized() As Boolean _
        Implements ICollection.IsSynchronized

        Get
            Return _people.IsSynchronized
        End Get
    End Property

    Public ReadOnly Property SyncRoot() As Object _
        Implements ICollection.SyncRoot

        Get
            Return _people.SyncRoot
        End Get
    End Property

    ' IEnumerable Members
    Public Function IEnumerableGetEnumerator() As IEnumerator _
        Implements IEnumerable.GetEnumerator

        Return New PeopleEnum(_people)
    End Function
End Class

Public Class PeopleEnum
    Implements IDictionaryEnumerator

    Public _people As ArrayList

    ' Enumerators are positioned before the first element
    ' until the first MoveNext() call.
    Dim position As Integer = -1

    Public Sub New(ByVal list As ArrayList)
        _people = list
    End Sub

    Public Function MoveNext() As Boolean _
        Implements IEnumerator.MoveNext

        position = position + 1
        Return (position < _people.Count)
    End Function

    Public Sub Reset() _
        Implements IEnumerator.Reset

        position = -1
    End Sub

    Public ReadOnly Property Current() As Object _
        Implements IEnumerator.Current

        Get
            Try
                Return _people(position)
            Catch e As IndexOutOfRangeException
                Throw New InvalidOperationException()
            End Try
        End Get
    End Property

    Public ReadOnly Property Entry() As DictionaryEntry _
        Implements IDictionaryEnumerator.Entry
        Get
            Return CType(Current, DictionaryEntry)
        End Get
    End Property

    Public ReadOnly Property Key() As Object _
        Implements IDictionaryEnumerator.Key

        Get
            Try
                Return CType(_people(position), DictionaryEntry).Key
            Catch e As IndexOutOfRangeException
                Throw New InvalidOperationException()
            End Try
        End Get
    End Property

    Public ReadOnly Property Value() As Object _
        Implements IDictionaryEnumerator.Value

        Get
            Try
                Return CType(_people(position), DictionaryEntry).Value
            Catch e As IndexOutOfRangeException
                Throw New InvalidOperationException()
            End Try
        End Get
    End Property
End Class

Class App
    Shared Sub Main()
        Dim peopleCollection As People = New People(3)
        peopleCollection.Add("John", "Smith")
        peopleCollection.Add("Jim", "Johnson")
        peopleCollection.Add("Sue", "Rabon")

        Console.WriteLine("Displaying the entries in peopleCollection:")
        Dim de As DictionaryEntry
        For Each de In peopleCollection
            Console.WriteLine("{0} {1}", de.Key, de.Value)
        Next

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

        For Each de In peopleCollection
            Console.WriteLine("{0} {1}", de.Key, de.Value)
        Next
    End Sub
End Class
' 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

Hinweise

IOrderedDictionary Auf Elemente kann entweder mit dem Schlüssel oder mit dem Index zugegriffen werden.

Jedes Element ist ein Schlüssel-Wert-Paar, das in einer DictionaryEntry Struktur gespeichert ist.

Jedes Paar muss über einen eindeutigen Schlüssel verfügen, der nicht nullist, aber der Wert kann null und muss nicht eindeutig sein. Die IOrderedDictionary Schnittstelle ermöglicht das Aufzählen der enthaltenen Schlüssel und Werte, impliziert jedoch keine bestimmte Sortierreihenfolge.

Die foreach -Anweisung der C#-Sprache (For Each in Visual Basic) gibt ein Objekt vom Typ der Elemente in der Auflistung zurück. Da jedes Element von IDictionary ein Schlüssel-Wert-Paar ist, ist der Elementtyp nicht der Typ des Schlüssels oder der Typ des Werts. Stattdessen ist DictionaryEntryder Elementtyp , wie das folgende Beispiel zeigt.

for each (DictionaryEntry de in myOrderedDictionary)
{
    //...
}
foreach (DictionaryEntry de in myOrderedDictionary)
{
    //...
}
For Each de In myOrderedDictionary
    '...
Next

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

Hinweise für Ausführende

Die implementierende Klasse muss über eine Möglichkeit zum Vergleichen von Schlüsseln verfügen.

Eigenschaften

Count

Ruft die Anzahl der Elemente ab, die in ICollection enthalten sind.

(Geerbt von ICollection)
IsFixedSize

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

(Geerbt von IDictionary)
IsReadOnly

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

(Geerbt von IDictionary)
IsSynchronized

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

(Geerbt von ICollection)
Item[Int32]

Ruft das Element am angegebenen Index ab oder legt dieses fest.

Item[Object]

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

(Geerbt von IDictionary)
Keys

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

(Geerbt von IDictionary)
SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf ICollection synchronisiert werden kann.

(Geerbt von ICollection)
Values

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

(Geerbt von IDictionary)

Methoden

Add(Object, Object)

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

(Geerbt von IDictionary)
Clear()

Entfernt alle Elemente aus dem IDictionary-Objekt.

(Geerbt von IDictionary)
Contains(Object)

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

(Geerbt von IDictionary)
CopyTo(Array, Int32)

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

(Geerbt von ICollection)
GetEnumerator()

Gibt einen Enumerator zurück, der die IOrderedDictionary-Auflistung durchläuft.

Insert(Int32, Object, Object)

Fügt ein Schlüssel-Wert-Paar beim angegebenen Index in die Auflistung ein.

Remove(Object)

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

(Geerbt von IDictionary)
RemoveAt(Int32)

Entfernt das Element am angegebenen Index.

Erweiterungsmethoden

Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ um

OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.

Gilt für:

Weitere Informationen