.NET 实现Hashlist--可以排序的哈希表

1. /// <summary>
2.     /// 
3.     /// </summary>
4.     public abstract class Hashlist : IDictionary, IEnumerable
5.     {
7.         //array list that contains all the keys 
8.         //as they are inserted, the index is associated with
9.         //a key so when pulling out values by index
10.         //we can get the key for the index, pull from the 
11.         //hashtable the proper value with the corresponding 
12.         //key
13.         //This is basically the same as a sorted list but
14.         //does not sort the items, rather it leaves them in the
15.         //order they were inserted - like a list
16.         /// <summary>
17.         /// 
18.         /// </summary>
19.         protected ArrayList m_oKeys = new ArrayList();
20.         /// <summary>
21.         /// 
22.         /// </summary>
23.         protected Hashtable m_oValues = new Hashtable();        
25.         #region ICollection implementation
26.         //ICollection implementation
27.         /// <summary>
28.         /// 
29.         /// </summary>
30.         public int Count
31.         {
32.             get{return m_oValues.Count;}
33.         }
34.         /// <summary>
35.         /// 
36.         /// </summary>
37.         public bool IsSynchronized
38.         {
39.             get{return m_oValues.IsSynchronized;}
40.         }
41.         /// <summary>
42.         /// 
43.         /// </summary>
44.         public object SyncRoot
45.         {
46.             get{return m_oValues.SyncRoot;}
47.         }
48.         /// <summary>
49.         /// 
50.         /// </summary>
51.         /// <param name="oArray"></param>
52.         /// <param name="iArrayIndex"></param>
53.         public void CopyTo(System.Array oArray, int iArrayIndex)
54.         {
55.             m_oValues.CopyTo(oArray, iArrayIndex);
56.         }
57.         #endregion
59.         #region IDictionary implementation
60.         //IDictionary implementation
61.         /// <summary>
62.         /// 
63.         /// </summary>
64.         /// <param name="oKey"></param>
65.         /// <param name="oValue"></param>
66.         public void Add(object oKey, object oValue)
67.         {
68.             m_oKeys.Add(oKey);
69.             m_oValues.Add(oKey, oValue);
70.         }
71.         /// <summary>
72.         /// 
73.         /// </summary>
74.         public bool IsFixedSize
75.         {
76.             get{return m_oKeys.IsFixedSize;}
77.         }
78.         /// <summary>
79.         /// 
80.         /// </summary>
81.         public bool IsReadOnly
82.         {
83.             get{return m_oKeys.IsReadOnly;}
84.         }
85.         /// <summary>
86.         /// 
87.         /// </summary>
88.         public ICollection Keys
89.         {
90.             get{return m_oValues.Keys;}
91.         }
92.         /// <summary>
93.         /// 
94.         /// </summary>
95.         public void Clear()
96.         {
97.             m_oValues.Clear();
98.             m_oKeys.Clear();
99.         }
100.         /// <summary>
101.         /// 
102.         /// </summary>
103.         /// <param name="oKey"></param>
104.         /// <returns></returns>
105.         public bool Contains(object oKey)
106.         {
107.             return m_oValues.Contains(oKey);
108.         }
109.         /// <summary>
110.         /// 
111.         /// </summary>
112.         /// <param name="oKey"></param>
113.         /// <returns></returns>
114.         public bool ContainsKey(object oKey)
115.         {
116.             return m_oValues.ContainsKey(oKey);
117.         }
118.         /// <summary>
119.         /// 
120.         /// </summary>
121.         /// <returns></returns>
122.         public IDictionaryEnumerator GetEnumerator()
123.         {
124.             return m_oValues.GetEnumerator();
125.         }   
126.         /// <summary>
127.         /// 
128.         /// </summary>
129.         /// <param name="oKey"></param>
130.         public void Remove(object oKey)
131.         {
132.             m_oValues.Remove(oKey);
133.             m_oKeys.Remove(oKey);
134.         }
135.         /// <summary>
136.         /// 
137.         /// </summary>
138.         public object this[object oKey]
139.         {
140.             get{return m_oValues[oKey];}
141.             set{m_oValues[oKey] = value;}
142.         }
143.         /// <summary>
144.         /// 
145.         /// </summary>
146.         public ICollection Values
147.         {
148.             get{return m_oValues.Values;}
149.         }
150.         #endregion
152.         #region IEnumerable implementation
153.         IEnumerator IEnumerable.GetEnumerator()
154.         {
155.             return m_oValues.GetEnumerator();
156.         }
157.         #endregion
158.         
159.         #region Hashlist specialized implementation
160.         //specialized indexer routines
161.         /// <summary>
162.         /// 
163.         /// </summary>
164.         public object this[string Key]
165.         {
166.             get{return m_oValues[Key];}
167.         }
168.         /// <summary>
169.         /// 
170.         /// </summary>
171.         public object this[int Index]
172.         {
173.             get{return m_oValues[m_oKeys[Index]];}
174.         }
175.         #endregion
176.     
177.     }