IDictionaryEnumerator インターフェイス

定義

名前空間:

System.Collections

アセンブリ:

netstandard.dll, System.Runtime.dll

非ジェネリック ディクショナリの要素を列挙します。

C#

public interface IDictionaryEnumerator : System.Collections.IEnumerator

派生

System.Collections.Generic.Dictionary<TKey,TValue>.Enumerator

System.Collections.Generic.OrderedDictionary<TKey,TValue>.Enumerator

System.Collections.Generic.SortedDictionary<TKey,TValue>.Enumerator

System.Windows.Markup.Localizer.BamlLocalizationDictionaryEnumerator

実装

IEnumerator

例

このコード例では、IDictionaryEnumerator インターフェイスを実装するディクショナリ列挙子を定義する方法を示します。

C#

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

注釈

C# 言語の foreach ステートメント (Visual Basic のfor each) では、列挙子の複雑さが隠されます。 そのため、列挙子を直接操作するのではなく、foreach を使用することをお勧めします。

列挙子を使用してコレクション内のデータを読み取ることができますが、基になるコレクションを変更するために使用することはできません。

最初は、列挙子はコレクション内の最初の要素の前に配置されます。 Reset メソッドは、列挙子もこの位置に戻します。 この位置では、Current は未定義です。 したがって、Currentの値を読み取る前に、MoveNext メソッドを呼び出して列挙子をコレクションの最初の要素に進める必要があります。

Current は、MoveNext または Reset が呼び出されるまで、同じオブジェクトを返します。 MoveNext Current を次の要素に設定します。

MoveNext がコレクションの末尾を渡す場合、列挙子はコレクション内の最後の要素の後に配置され、MoveNext は falseを返します。 列挙子がこの位置にある場合、後続の MoveNext の呼び出しでも falseが返されます。 MoveNext の最後の呼び出しが false返された場合、Current は未定義です。 Current をコレクションの最初の要素に再度設定するには、Reset を呼び出し、その後に MoveNextを呼び出します。

列挙子は、コレクションが変更されない限り有効なままです。 要素の追加、変更、削除など、コレクションに変更が加えられた場合、列挙子は回復不能に無効になり、次に MoveNext または Reset を呼び出すと、InvalidOperationExceptionがスローされます。

列挙子は、コレクションへの排他的アクセス権を持っていません。したがって、コレクションを通じた列挙は、本質的にスレッド セーフなプロシージャではありません。 コレクションが同期されている場合でも、他のスレッドはコレクションを変更できるため、列挙子は例外をスローします。 列挙中のスレッド セーフを保証するには、列挙全体の間にコレクションをロックするか、他のスレッドによって行われた変更によって発生する例外をキャッチします。

注意 (実装者)

IEnumerator から継承された Current プロパティは、ボックス化された DictionaryEntryである Object を返します。 Entry は Objectではなく DictionaryEntry を返す点を除いて、Entry プロパティに似ています。

プロパティ

Current	列挙子の現在位置にあるコレクション内の要素を取得します。 (継承元 IEnumerator)
Entry	キーと現在のディクショナリ エントリの値の両方を取得します。
Key	現在のディクショナリ エントリのキーを取得します。
Value	現在のディクショナリ エントリの値を取得します。

メソッド

MoveNext()	列挙子をコレクションの次の要素に進めます。 (継承元 IEnumerator)
Reset()	列挙子を最初の位置 (コレクション内の最初の要素の前) に設定します。 (継承元 IEnumerator)

適用対象

こちらもご覧ください

• IDictionary
• IEnumerator
• IEnumerator<T>