エクスポート (0) 印刷
すべて展開
情報
要求されたトピックは次のとおりです。しかし、このトピックはこのライブラリには含まれていません。

IDictionary インターフェイス

2013/12/12

キー/値ペアの非ジェネリック コレクションを表します。

Namespace:  System.Collections
アセンブリ:  mscorlib (mscorlib.dll 内)

public interface IDictionary : ICollection, 
	IEnumerable

IDictionary 型で公開されるメンバーは以下のとおりです。

  名前説明
パブリック プロパティCountICollection に格納されている要素の数を取得します。 (ICollection から継承されます。)
パブリック プロパティIsFixedSizeIDictionary オブジェクトが固定サイズかどうかを示す値を取得します。
パブリック プロパティIsReadOnlyIDictionary オブジェクトが読み取り専用かどうかを示す値を取得します。
パブリック プロパティIsSynchronizedICollection へのアクセスが同期されている (スレッド セーフである) かどうかを示す値を取得します。 (ICollection から継承されます。)
パブリック プロパティItem指定したキーを持つ要素を取得または設定します。
パブリック プロパティKeysIDictionary オブジェクトのキーを格納している ICollection オブジェクトを取得します。
パブリック プロパティSyncRootICollection へのアクセスを同期するために使用できるオブジェクトを取得します。 (ICollection から継承されます。)
パブリック プロパティValuesIDictionary オブジェクト内の値を格納している ICollection オブジェクトを取得します。
このページのトップへ

  名前説明
パブリック メソッドAdd指定したキーおよび値を持つ要素を IDictionary オブジェクトに追加します。
パブリック メソッドClearIDictionary オブジェクトからすべての要素を削除します。
パブリック メソッドContains指定したキーを持つ要素が IDictionary オブジェクトに格納されているかどうかを判断します。
パブリック メソッドCopyToICollection の要素を Array にコピーします。Array の特定のインデックスからコピーが開始されます。 (ICollection から継承されます。)
パブリック メソッドGetEnumerator()IDictionary オブジェクトの IDictionaryEnumerator オブジェクトを返します。
パブリック メソッドGetEnumerator()コレクションを反復処理する列挙子を返します。 (IEnumerable から継承されます。)
パブリック メソッドRemove指定したキーを持つ要素を IDictionary オブジェクトから削除します。
このページのトップへ

  名前説明
パブリック拡張メソッドAsQueryableIEnumerableIQueryable に変換します。 (Queryable によって定義されています。)
パブリック拡張メソッドCast<TResult>IEnumerable の要素を、指定した型に変換します。 (Enumerable によって定義されています。)
パブリック拡張メソッドOfType<TResult>指定された型に基づいて IEnumerable の要素をフィルター処理します。 (Enumerable によって定義されています。)
このページのトップへ

IDictionary インターフェイスは、キー/値ペアの非ジェネリック コレクションに対する基本インターフェイスです。このインターフェイスのジェネリック バージョンについては、「System.Collections.Generic.IDictionary<TKey, TValue>」を参照してください。

各要素は、DictionaryEntry オブジェクトに格納されているキー/値ペアです。

各ペアが一意なキーを持っている必要があります。キーを null にできるかどうかは、実装によって異なります。キーの値が null になることを許容する場合は、キーを一意にする必要はありません。IDictionary インターフェイスを使用すると、保持されているキーと値を列挙できますが、特定の並べ替え順序は指定できません。

IDictionary の実装には、読み取り専用、固定サイズ、および可変サイズの 3 種類があります。読み取り専用の IDictionary オブジェクトは、変更できません。固定サイズの IDictionary オブジェクトでは、要素の追加または削除はできませんが、既存の要素は変更できます。可変サイズの IDictionary オブジェクトでは、要素を追加、削除、および変更できます。

C# 言語の foreach ステートメント (Visual Basic の場合は for each) は、コレクション内の各要素の型を必要とします。IDictionary オブジェクトの各要素はキー/値ペアであるため、要素の型は、キーの型や値の型にはなりません。その代わり、要素の型は DictionaryEntry になります。次に例を示します。

foreach (DictionaryEntry de in CastMembers) {...}

foreach ステートメントは、列挙子のラッパーです。これは、コレクションからの読み取りだけを許可し、コレクションへの書き込みを防ぎます。

実装時の注意

実装クラスは、キーを比較する手段を備えている必要があります。

IDictionary インターフェイスを実装する単純なディクショナリ クラスを定義する方法を次のコード例に示します。

メモメモ:

この例を実行するには、「Windows Phone での静的 TextBlock コントロールのあるコード例のビルド」を参照してください。


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 Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // 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);

      outputBlock.Text += String.Format("Number of elements in dictionary = {0}", d.Count) + "\n";

      outputBlock.Text += String.Format("Does dictionary contain 'Jeff'? {0}", d.Contains("Jeff")) + "\n";
      outputBlock.Text += String.Format("Jeff's age is {0}", d["Jeff"]) + "\n";

      // Display every entry's key and value.
      foreach (DictionaryEntry de in d)
      {
         outputBlock.Text += String.Format("{0} is {1} years old.", de.Key, de.Value) + "\n";
      }

      // 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)
         outputBlock.Text += s + "\n";

      // Show the ages (values) of the people in the dictionary.
      foreach (Int32 age in d.Values)
         outputBlock.Text += age + "\n";
   }
}

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


Windows Phone OS

サポート: 8.0, 7.1, 7.0

表示:
© 2014 Microsoft