构建可反转排序的泛型字典类(4)--IDictionary接口

 

C#对集合类型有统一的规范。它的好处不言而喻，所有集合类都有一些统一的调用方法和属性，这使得学习成本大大降低。统一的规范就是通过接口来实现的（关于接口，如果不熟，请参考

http://www.enet.com.cn/eschool/video/c/30.shtml ），另一方面一些类也会直接调用这些标准接口，使得我们写出来的类有更好的兼容性。最典型的例子莫过于IEnumerable接口，只要实现了它就可以使用foreach语句进行调用。

我们将要给ReversibleSortedList实现的是IDictionary接口，先来看看它的定义：

public interface IDictionary : ICollection, IEnumerable

ICollection接口是所有集合类的基接口，FCL中所有集合，不管是哪种方式的集合都实现它。IEnumerable接口则是枚举器接口，实现了它就可以使用foreach语句对它进行访问。IDictionary接口则继承自这两个接口，它表示键/值对的非通用集合。

ICollection接口的定义为：

public interface ICollection : IEnumerable

从这个定义可以看出，所有集合类都应该支持foreach语句进行访问。

表1列出了各个接口的成员

接口	成员	说明
ICollection	Count属性	获取 ICollection 中包含的元素数
	IsSynchronized属性	获取一个值，该值指示是否同步对 ICollection 的访问（线程安全）
	SyncRoot属性	获取可用于同步 ICollection 访问的对象
	CopyTo方法	从特定的 Array 索引处开始，将 ICollection 的元素复制到一个 Array 中
IEnumerable	GetEnumerator方法	返回一个循环访问集合的枚举器
IDictionary	IsFixedSize属性	获取一个值，该值指示 IDictionary 对象是否具有固定大小
	IsReadOnly属性	获取一个值，该值指示 IDictionary 对象是否为只读
	Item属性	获取或设置具有指定键的元素
	Keys属性	获取 ICollection 对象，它包含 IDictionary 对象的键
	Values属性	获取 ICollection 对象，它包含 IDictionary 对象中的值
	Add方法	在 IDictionary 对象中添加一个带有所提供的键和值的元素
	Clear方法	从 IDictionary 对象中移除所有元素
	Contains方法	确定 IDictionary 对象是否包含具有指定键的元素
	GetEnumerator方法	返回一个用于 IDictionary 对象的 IDictionaryEnumerator 对象
	Remove方法	从 IDictionary 对象中移除带有指定键的元素

从上表可以看出，实现IDictionary接口并不简单。我个人喜欢先把复杂的问题简单化，但所要实现的东西实在太多，只能尽力而为。如果在我们之前所构建的ReversibleSortedList类中加上这么代码将不利于理解如何实现IDictionary接口。所以我从MSDN上copy了一段IDictionary接口实现的代码，并把所有属于出错判断的部分咔嚓掉，先让大家对IDictionary接口有个了解后再给ReversibleSortedList类实现它。

实现这个接口需要注意以下几点：

1.         IEnumerable接口的GetEnumerator方法的实现，这个方法的原型为：

IEnumerator GetEnumerator()

也就是说这个方法返回的是一个实现了IEnumerator的类，IEnumerator接口的成员如下：

Current属性：获取集合中的当前元素

MoveNext方法：将枚举数推进到集合的下一个元素

Reset方法：将枚举数设置为其初始位置，该位置位于集合中第一个元素之前

实现了IEnumerator接口的类可以通过一个内部类来实现，又要多实现三个成员，事态变得进一步复杂。关于IEnumerable接口实现，如果不懂可以上网搜搜，能搜一大箩筐出来，也可以参考设计模式中的“Iterator 迭代器模式”进行学习。

IDictionary接口中有自己的GetEnumerator方法，它返回的IEnumerator接口的子接口：IDictionaryEnumerator接口。这个接口的定义为：

public interface IDictionaryEnumerator : IEnumerator

它的成员为：

Entry：同时获取当前字典项的键和值

Key：获取当前字典项的键

Value：获取当前字典项的值

这意味着除了要实现IEnumerable接口的三个成员外，还要实现它自己的三个成员，变得更复杂了，晕！值得庆幸的是由于IDictionaryEnumerator接口继承自IEnumerator接口，可以把IDictionaryEnumerator接口强制转换为IEnumerator接口用于实现IEnumerable接口的GetEnumerator方法。当然，由于两个方法同名，只能给IEnumerable接口用显示接口成员实现了。

2.         Item属性，这个属性并不是叫你实现了个名字叫“Item”的属性，而是一个索引器，通过实例名加方括号中的索引来访问集合里的元素。关于索引器，如果不熟，请参考：

http://www.enet.com.cn/eschool/video/c/20.shtml 。

3.         Keys属性，这个属性的原型为：

ICollection Keys { get; }

也就是说，它返回一个实现了ICollection接口的类。ICollection接口前面已经讲过，C#中的所有集合类都实现了它。本例中这个属性返回的是一个数组，因为数组也实现了ICollection接口。另外Values属性也是同样的情况。

4.         本例中，字典集合里的一个元素是由键和值组成的，这一个元素使用了FCL中现成的DictionaryEntry来实现，它定义了可设置或检索的字典键/值对。

下面列出了代码，请大家参照注释进行理解。

IDictionary接口的实现（以下代码可直接拷贝并运行）

using  System;
using  System.Collections;

public   class  SimpleDictionary : IDictionary
{
     private  DictionaryEntry[] items;  // 用数组存放元素
     private  Int32 ItemsInUse  =   0 ;  // 元素个数
     // 指定存储空间的构造方法
     public  SimpleDictionary(Int32 numItems)
    {
        items  =   new  DictionaryEntry[numItems];
    }
     #region  IDictionary 成员
     public   bool  IsReadOnly {  get  {  return   false ; } }
     public   bool  Contains( object  key)
    {   // 检测是否包含指定的key键
       Int32 index;
        return  TryGetIndexOfKey(key,  out  index);
    }
     public   bool  IsFixedSize {  get  {  return   false ; } }
     public   void  Remove( object  key)
    {    // 移除指定键的元素
        Int32 index;
         if  (TryGetIndexOfKey(key,  out  index))
        {    // 把移除元素后面的所有元素向前移动一个位置
            Array.Copy(items, index  +   1 , items, index, ItemsInUse  -  index  -   1 );
            ItemsInUse -- ;
        } 
    }
     public   void  Clear() { ItemsInUse  =   0 ; }  // 清除所有元素
     public   void  Add( object  key,  object  value) 
    {    // 添加一个元素
        items[ItemsInUse ++ ]  =   new  DictionaryEntry(key, value);
    }
     public  ICollection Keys
    {    // 返回所有键的集合
         get
        {    // 把所有键的集合拷贝到新数组中并返回
            Object[] keys  =   new  Object[ItemsInUse];
             for  (Int32 n  =   0 ; n  <  ItemsInUse; n ++ )
                keys[n]  =  items[n].Key;
             return  keys;
        }
    }
     public  ICollection Values
    {    // 返回所有值的集合
         get
        {    // 把所有值的集合拷贝到新数组中并返回
            Object[] values  =   new  Object[ItemsInUse];
             for  (Int32 n  =   0 ; n  <  ItemsInUse; n ++ )
                values[n]  =  items[n].Value;
             return  values;
        }
    }
     public   object   this [ object  key]
    {    // item属性的实现，也就是索引器
         get
        {   
            Int32 index;
             if  (TryGetIndexOfKey(key,  out  index))
            {
                 return  items[index].Value;
            } 
             return   null ;
        }
         set
        {
            Int32 index;
             if  (TryGetIndexOfKey(key,  out  index))
            {
                items[index].Value  =  value;
            } 
             else
            {
                Add(key, value);
            }
        }
    }
     // 这个方法有两个作用，第一是查找指定键是否存在
     // 第二是返回指定键的索引
     private  Boolean TryGetIndexOfKey(Object key,  out  Int32 index)
    {
         for  (index  =   0 ; index  <  ItemsInUse; index ++ )
        {
             if  (items[index].Key.Equals(key))  return   true ;
        }
         return   false ;
    }
     // 用于迭代的嵌套类，它同时实现了IEnumerator和IDictionaryEnumerator
     private   class  SimpleDictionaryEnumerator : IDictionaryEnumerator
    {
        DictionaryEntry[] items;
        Int32 index  =   - 1 ;
         // 构造方法，用于获得SimpleDictionary类的所有元素
         public  SimpleDictionaryEnumerator(SimpleDictionary sd)
        {
            items  =   new  DictionaryEntry[sd.Count];
            Array.Copy(sd.items,  0 , items,  0 , sd.Count);
        }
         public  Object Current 
        { 
             get  {  return  items[index]; }
        }
         public  DictionaryEntry Entry
        {
             get  {  return  (DictionaryEntry) Current; }
        }
         public  Object Key {  get  {  return  items[index].Key; } }
         public  Object Value {  get  {  return  items[index].Value; } }
         public  Boolean MoveNext()
        {
             if  (index  <  items.Length  -   1 ) { index ++ ;  return   true ; }
             return   false ;
        }
         public   void  Reset()
        {
            index  =   - 1 ;
        }
    }
     // 实现IDictionary接口中的GetEnumerator方法
     public  IDictionaryEnumerator GetEnumerator()
    {
         return   new  SimpleDictionaryEnumerator( this );
    }
     #endregion

     #region  ICollection 成员
     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 成员
     // 实现IEnumerable接口的GetEnumerator方法
    IEnumerator IEnumerable.GetEnumerator() 
    {
         //  这里使用了强制类型转换.
         return  ((IDictionary) this ).GetEnumerator();
    }
     #endregion
}
public   sealed   class  App
{
     static   void  Main()
    {
         //  创建一个只能包含三个元素的字典类
        IDictionary d  =   new  SimpleDictionary( 3 );
         //  添加三个人名和它们的年龄到字典内
        d.Add( " Jeff " ,  40 );
        d.Add( " Kristin " ,  34 );
        d.Add( " Aidan " ,  1 );
        Console.WriteLine( " 字典元素个数= {0} " , d.Count);
        Console.WriteLine( " 字典中是否包含'Jeff'? {0} " , d.Contains( " Jeff " ));
        Console.WriteLine( " Jeff的年龄是：{0} " , d[ " Jeff " ]);
         //  显示字典中的所有键和值，由于实现了IDictionaryEnumerator接口
         // 所以可以使用foreach进行调用
         foreach  (DictionaryEntry de  in  d)
        {
            Console.WriteLine( " {0} is {1} years old. " , de.Key, de.Value);
        }
         //  移除“Jeff”
        d.Remove( " Jeff " );
         //  移除不存在的元素不会引发异常
        d.Remove( " Max " );
         //  显示字典中的所有人名（key）
         foreach  (String s  in  d.Keys)
            Console.WriteLine(s);
         //  显示字典中的所有年龄（value)
         foreach  (Int32 age  in  d.Values)
            Console.WriteLine(age);
    }
}