IOrderedDictionary Interface

Définition

Espace de noms:

System.Collections.Specialized

Assembly:

System.Collections.Specialized.dll

Représente une collection indexée de paires clé/valeur.

C#

public interface IOrderedDictionary : System.Collections.IDictionary

Dérivé

System.Collections.Specialized.OrderedDictionary

Implémente

ICollection IDictionary IEnumerable

Exemples

L’exemple de code suivant illustre l’implémentation d’un simple IOrderedDictionary basé sur la ArrayList classe . Le implémenté IOrderedDictionary stocke les prénoms en tant que clés et les noms de famille en tant que valeurs, avec l’exigence supplémentaire que chaque prénom est unique.

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

Remarques

IOrderedDictionary les éléments sont accessibles avec la clé ou avec l’index.

Chaque élément est une paire clé/valeur stockée dans une DictionaryEntry structure.

Chaque paire doit avoir une clé unique qui n’est pas null, mais la valeur peut être null et ne doit pas être unique. L’interface IOrderedDictionary permet d’énumérer les clés et valeurs contenues, mais elle n’implique pas d’ordre de tri particulier.

L’instruction foreach du langage C# (For Each en Visual Basic) retourne un objet du type des éléments de la collection. Étant donné que chaque élément de est IDictionary une paire clé/valeur, le type d’élément n’est pas le type de la clé ou le type de la valeur. Au lieu de cela, le type d’élément est DictionaryEntry, comme le montre l’exemple suivant.

C#

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

L’instruction foreach est un wrapper autour de l’énumérateur, qui autorise uniquement la lecture à partir de la collection, et non l’écriture dans.

Notes pour les responsables de l’implémentation

La classe d’implémentation doit avoir un moyen de comparer les clés.

Propriétés

Count	Obtient le nombre d’éléments contenus dans le ICollection. (Hérité de ICollection)
IsFixedSize	Obtient une valeur indiquant si l'objet IDictionary est de taille fixe. (Hérité de IDictionary)
IsReadOnly	Obtient une valeur indiquant si l’objet IDictionary est en lecture seule. (Hérité de IDictionary)
IsSynchronized	Obtient une valeur indiquant si l’accès à ICollection est synchronisé (thread-safe). (Hérité de ICollection)
Item[Int32]	Obtient ou définit l'élément au niveau de l'index spécifié.
Item[Object]	Obtient ou définit l'élément à l'aide de la clé spécifiée. (Hérité de IDictionary)
Keys	Obtient un objet ICollection contenant les clés de l'objet IDictionary. (Hérité de IDictionary)
SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l’accès à ICollection. (Hérité de ICollection)
Values	Obtient un objet ICollection contenant les valeurs de l'objet IDictionary. (Hérité de IDictionary)

Méthodes

Add(Object, Object)	Ajoute un élément avec la clé et la valeur fournies à l'objet IDictionary. (Hérité de IDictionary)
Clear()	Supprime tous les éléments de l'objet IDictionary. (Hérité de IDictionary)
Contains(Object)	Détermine si l'objet IDictionary contient un élément avec la clé spécifiée. (Hérité de IDictionary)
CopyTo(Array, Int32)	Copie les éléments de ICollection dans Array, à partir d'un index particulier de Array. (Hérité de ICollection)
GetEnumerator()	Retourne un énumérateur qui itère au sein de la collection IOrderedDictionary.
Insert(Int32, Object, Object)	Insère une paire clé/valeur dans la collection à l’index spécifié.
Remove(Object)	Supprime de l’objet IDictionary l’élément ayant la clé spécifiée. (Hérité de IDictionary)
RemoveAt(Int32)	Supprime l'élément au niveau de l'index spécifié.

Méthodes d’extension

Cast<TResult>(IEnumerable)	Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d'une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

S’applique à

Voir aussi

• ICollection
• IDictionary