导出 (0) 打印
全部展开
信息
您所需的主题如下所示。但此主题未包含在此库中。

IDictionary 接口

2013/12/13

表示键/值对的非通用集合。

Namespace:  System.Collections
程序集:  mscorlib(位于 mscorlib.dll 中)

public interface IDictionary : ICollection, 
	IEnumerable

IDictionary 类型公开以下成员。

  名称说明
公共属性Count获取 ICollection 中包含的元素数。 (从 ICollection 继承。)
公共属性IsFixedSize获取一个值,该值指示 IDictionary 对象是否具有固定大小。
公共属性IsReadOnly获取一个值,该值指示 IDictionary 对象是否为只读。
公共属性IsSynchronized获取一个值,该值指示是否同步对 ICollection 的访问(线程安全)。 (从 ICollection 继承。)
公共属性Item获取或设置具有指定键的元素。
公共属性Keys获取 ICollection 对象,它包含 IDictionary 对象的键。
公共属性SyncRoot获取可用于同步对 ICollection 的访问的对象。 (从 ICollection 继承。)
公共属性Values获取 ICollection 对象,它包含 IDictionary 对象中的值。
返回顶部

  名称说明
公共方法AddIDictionary 对象中添加一个带有所提供的键和值的元素。
公共方法ClearIDictionary 对象中移除所有元素。
公共方法Contains确定 IDictionary 对象是否包含具有指定键的元素。
公共方法CopyTo从特定的 Array 索引开始,将 ICollection 的元素复制到一个 Array 中。 (从 ICollection 继承。)
公共方法GetEnumerator()返回一个用于 IDictionary 对象的 IDictionaryEnumerator 对象。
公共方法GetEnumerator()返回一个循环访问集合的枚举器。 (从 IEnumerable 继承。)
公共方法RemoveIDictionary 对象中移除具有指定键的元素。
返回顶部

  名称说明
公共扩展方法AsQueryableIEnumerable 转换为 IQueryable (由 Queryable 定义。)
公共扩展方法Cast<TResult>IEnumerable 的元素转换为指定的类型。 (由 Enumerable 定义。)
公共扩展方法OfType<TResult>根据指定类型筛选 IEnumerable 的元素。 (由 Enumerable 定义。)
返回顶部

IDictionary 接口是键/值对的非通用集合的基接口。有关此接口的泛型版本,请参见 System.Collections.Generic.IDictionary<TKey, TValue>

每个元素都是一个存储在 DictionaryEntry 对象中的键/值对。

每一对都必须有唯一的键。实现在是否允许键为 null 方面有所不同。此值可以为 null,并且不必是唯一的。IDictionary 接口允许对所包含的键和值进行枚举,但这并不意味着任何特定的排序顺序。

IDictionary 实现分为三个类别:只读、固定大小、可变大小。无法修改只读 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

Windows Phone

显示:
© 2014 Microsoft