IOrderedDictionary Interfejs

Definicja

Reprezentuje indeksowaną kolekcję par klucz/wartość.

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
Pochodne
Implementuje

Przykłady

Poniższy przykład kodu przedstawia implementację prostego IOrderedDictionary kodu na ArrayList podstawie klasy. Zaimplementowane IOrderedDictionary nazwy są przechowywane jako klucze i nazwiska jako wartości, z dodanym wymaganiem, że każde imię jest unikatowe.


#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

Uwagi

IOrderedDictionary dostęp do elementów można uzyskać za pomocą klucza lub indeksu.

Każdy element to para klucz/wartość przechowywana DictionaryEntry w strukturze.

Każda para musi mieć unikatowy klucz, który nie nulljest , ale może być null wartością i nie musi być unikatowa. Interfejs IOrderedDictionary umożliwia wyliczanie zawartych kluczy i wartości, ale nie oznacza żadnej określonej kolejności sortowania.

Instrukcja foreach języka C# (For Eachw Visual Basic) zwraca obiekt typu elementów w kolekcji. Ponieważ każdy element IDictionary elementu jest parą klucz/wartość, typ elementu nie jest typem klucza ani typem wartości. Zamiast tego typ elementu to DictionaryEntry, jak pokazano w poniższym przykładzie.

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

Instrukcja foreach jest otoką wokół modułu wyliczającego, który umożliwia odczytywanie tylko z, a nie zapisywania do kolekcji.

Uwagi dotyczące implementowania

Klasa implementowania musi mieć metodę porównywania kluczy.

Właściwości

Count

Pobiera liczbę elementów zawartych w słowniku ICollection.

(Odziedziczone po ICollection)
IsFixedSize

Pobiera wartość wskazującą, czy IDictionary obiekt ma stały rozmiar.

(Odziedziczone po IDictionary)
IsReadOnly

Pobiera wartość wskazującą, czy IDictionary obiekt jest tylko do odczytu.

(Odziedziczone po IDictionary)
IsSynchronized

Pobiera wartość wskazującą, czy dostęp do elementu ICollection jest synchronizowany (bezpieczny wątk).

(Odziedziczone po ICollection)
Item[Int32]

Pobiera lub ustawia element pod określonym indeksem.

Item[Object]

Pobiera lub ustawia element przy użyciu określonego klucza.

(Odziedziczone po IDictionary)
Keys

ICollection Pobiera obiekt zawierający klucze IDictionary obiektu.

(Odziedziczone po IDictionary)
SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do obiektu ICollection.

(Odziedziczone po ICollection)
Values

ICollection Pobiera obiekt zawierający wartości w IDictionary obiekcie.

(Odziedziczone po IDictionary)

Metody

Add(Object, Object)

Dodaje element z podanym kluczem i wartością IDictionary do obiektu.

(Odziedziczone po IDictionary)
Clear()

Usuwa wszystkie elementy z IDictionary obiektu.

(Odziedziczone po IDictionary)
Contains(Object)

Określa, IDictionary czy obiekt zawiera element z określonym kluczem.

(Odziedziczone po IDictionary)
CopyTo(Array, Int32)

Kopiuje elementy ICollection elementu do obiektu Array, zaczynając od określonego Array indeksu.

(Odziedziczone po ICollection)
GetEnumerator()

Zwraca moduł wyliczający, który iteruje przez IOrderedDictionary kolekcję.

Insert(Int32, Object, Object)

Wstawia parę klucz/wartość do kolekcji w określonym indeksie.

Remove(Object)

Usuwa element z określonym kluczem IDictionary z obiektu.

(Odziedziczone po IDictionary)
RemoveAt(Int32)

Usuwa element w określonym indeksie.

Metody rozszerzania

Cast<TResult>(IEnumerable)

Rzutuje elementy elementu IEnumerable na określony typ.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable elementu na podstawie określonego typu.

AsParallel(IEnumerable)

Umożliwia równoległość zapytania.

AsQueryable(IEnumerable)

Konwertuje element IEnumerable na .IQueryable

Dotyczy

Zobacz też