IOrderedDictionary Arabirim

Tanım

Ad Alanı:

System.Collections.Specialized

Bütünleştirilmiş Kod:

System.Collections.Specialized.dll

Dizine alınan anahtar/değer çiftleri koleksiyonunu temsil eder.

C#

public interface IOrderedDictionary : System.Collections.IDictionary

Türetilmiş

System.Collections.Specialized.OrderedDictionary

Uygulamalar

ICollection IDictionary IEnumerable

Örnekler

Aşağıdaki kod örneği, sınıfını temel alan ArrayList basit IOrderedDictionary bir uygulamanın uygulanmasını gösterir. Uygulanan IOrderedDictionary adlar anahtarlar ve soyadları değerler olarak depolar ve her adın benzersiz olması gereksinimi eklenir.

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

Açıklamalar

IOrderedDictionary öğelerine anahtarla veya dizinle erişilebilir.

Her öğe, bir yapıda depolanan bir DictionaryEntry anahtar/değer çiftidir.

Her çift, olmayan nullbenzersiz bir anahtara sahip olmalıdır, ancak değer olabilir null ve benzersiz olması gerekmez. Arabirimi, IOrderedDictionary kapsanan anahtarların ve değerlerin numaralandırılmasına izin verir, ancak belirli bir sıralama düzenini ima etmez.

foreach C# dilinin deyimi (For EachVisual Basic'te) koleksiyondaki öğelerin türünde bir nesne döndürür. öğesinin IDictionary her öğesi bir anahtar/değer çifti olduğundan, öğe türü anahtarın türü veya değerin türü değildir. Bunun yerine, aşağıdaki örnekte gösterildiği gibi öğe türü şeklindedir DictionaryEntry.

C#

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

deyimi foreach , numaralandırıcının etrafındaki bir sarmalayıcıdır ve bu sarmalayıcı yalnızca koleksiyonun okumasına izin verir, yazmaya değil.

Uygulayanlara Notlar

Uygulayan sınıfın anahtarları karşılaştırmak için bir yöntemi olmalıdır.

Özellikler

Count	ICollection içindeki öğe sayısını alır. (Devralındığı yer: ICollection)
IsFixedSize	Nesnenin sabit bir boyuta IDictionary sahip olup olmadığını belirten bir değer alır. (Devralındığı yer: IDictionary)
IsReadOnly	Nesnenin IDictionary salt okunur olup olmadığını belirten bir değer alır. (Devralındığı yer: IDictionary)
IsSynchronized	erişimin ICollection eşitlenip eşitlenmediğini belirten bir değer alır (iş parçacığı güvenli). (Devralındığı yer: ICollection)
Item[Int32]	Belirtilen dizindeki öğeyi alır veya ayarlar.
Item[Object]	Belirtilen anahtarla öğesini alır veya ayarlar. (Devralındığı yer: IDictionary)
Keys	Nesnenin anahtarlarını IDictionary içeren bir ICollection nesne alır. (Devralındığı yer: IDictionary)
SyncRoot	erişimi ICollectioneşitlemek için kullanılabilecek bir nesnesi alır. (Devralındığı yer: ICollection)
Values	Nesnedeki IDictionary değerleri içeren bir ICollection nesneyi alır. (Devralındığı yer: IDictionary)

Yöntemler

Add(Object, Object)	Sağlanan anahtar ve değere sahip bir öğeyi nesnesine IDictionary ekler. (Devralındığı yer: IDictionary)
Clear()	Nesneden IDictionary tüm öğeleri kaldırır. (Devralındığı yer: IDictionary)
Contains(Object)	Nesnenin belirtilen anahtara IDictionary sahip bir öğe içerip içermediğini belirler. (Devralındığı yer: IDictionary)
CopyTo(Array, Int32)	öğesinin öğelerini ICollection belirli Array bir Arraydizinden başlayarak öğesine kopyalar. (Devralındığı yer: ICollection)
GetEnumerator()	Koleksiyonda IOrderedDictionary yineleyen bir numaralandırıcı döndürür.
Insert(Int32, Object, Object)	Belirtilen dizindeki koleksiyona bir anahtar/değer çifti ekler.
Remove(Object)	Belirtilen anahtara sahip öğesini nesneden IDictionary kaldırır. (Devralındığı yer: IDictionary)
RemoveAt(Int32)	Belirtilen dizindeki öğesini kaldırır.

Uzantı Metotları

Cast<TResult>(IEnumerable)	öğesinin IEnumerable öğelerini belirtilen türe atar.
OfType<TResult>(IEnumerable)	Bir öğesinin IEnumerable öğelerini belirtilen türe göre filtreler.
AsParallel(IEnumerable)	Sorgunun paralelleştirilmesini sağlar.
AsQueryable(IEnumerable)	bir IEnumerable öğesini öğesine IQueryabledönüştürür.

Şunlara uygulanır

Ayrıca bkz.

• ICollection
• IDictionary