代码已经经过初步测试,未来会有更多的类方上来,包括
Hashtable 存放非重复key的无序列表(.net标准类库,不需要重写)
HashArray 存放非重复key的有序列表
Bag 存放重复key的有序列表
Map 存放重复key的无序列表

/**/////////
using System;
using System.Collections;

namespace deltav.Collections


{


/**//// <summary>可以有键值重复的无序列表</summary>
public class Map : IDictionary, IDisposable

{

Internal Data#region Internal Data
internal Hashtable m_InternalData;
int m_Count = 0;
internal int m_Version = 0;
#endregion


Constructors#region Constructors
public Map()

{
m_InternalData = new Hashtable();
}

#endregion


Internal Functions#region Internal Functions

/**//// <summary>
/// 确保 key 对应的容器存在,并返回该容器
/// </summary>
/// <param name="key">key</param>
/// <returns>key 对应的容器</returns>
protected ArrayList MakeKeyExist(object key)

{
if (key == null)
throw new ArgumentNullException("key");
if (!m_InternalData.ContainsKey(key))

{
ArrayList containor = new ArrayList();
m_InternalData.Add(key, containor);
++m_Version;
return containor;
}
else
return (ArrayList)m_InternalData[key];
}


/**//// <summary>
/// 清理部分数据内容
/// </summary>
protected void ParticalClear()

{
foreach (DictionaryEntry ent in this.m_InternalData)
((ArrayList)ent.Value).Clear();
m_Count = 0;
++m_Version;
}


/**//// <summary>
/// 取得实际数据
/// </summary>
protected int GetCount()

{
int count = 0;
foreach (DictionaryEntry ent in this.m_InternalData)
count += ((ArrayList)ent.Value).Count;

return count;
}

#endregion


/**//// <summary>
/// 计算key对应的对象个数
/// </summary>
/// <param name="key">key</param>
/// <returns>对象个数</returns>
public int CountKey(object key)

{
if (this.m_InternalData.ContainsKey(key))
return ((ArrayList)this.m_InternalData[key]).Count;
else
return 0;
}

public void RemoveAt(object key, int index)

{
if (m_InternalData.ContainsKey(key))

{
MakeKeyExist(key).RemoveAt(index);
--m_Count;
++m_Version;
}
else
throw new ArgumentOutOfRangeException("index");
}

public object this[object key, int index]

{
get

{
if (this.m_InternalData.ContainsKey(key))

{
return MakeKeyExist(key)[index];
}
else
throw new ArgumentOutOfRangeException("index");
}
set

{
MakeKeyExist(key)[index] = value;
}
}

IEnumerator GetEnumerator(object key)

{
if (this.m_InternalData.ContainsKey(key))
return MakeKeyExist(key).GetEnumerator();
else
return null;
}


Internal Enumerator#region Internal Enumerator

private class MapEnumerator : IDictionaryEnumerator

{
Map m_Owner;
IDictionaryEnumerator master; // master == null 尚未开始
IEnumerator slave;
int version;
object current; // current == null 已经结束

public MapEnumerator(Map owner)

{
m_Owner = owner;
master = null;
slave = null;
current = null;
version = owner.m_Version;
}


IDictionaryEnumerator Members#region IDictionaryEnumerator Members
public DictionaryEntry Entry

{
get

{
if (master == null)
throw new InvalidOperationException("迭代尚未开始");
if (current == null)
throw new InvalidOperationException("迭代已经结束");
if (version != m_Owner.m_Version)
throw new InvalidOperationException("迭代期间数据已经被改变");
return (DictionaryEntry)current;
}
}

public object Key

{

get
{ return Entry.Key; }
}

public object Value

{

get
{ return Entry.Value; }
}


#endregion


IEnumerator Members#region IEnumerator Members
public object Current

{

get
{ return Entry; }
}


public bool MoveNext()

{
if (version != m_Owner.m_Version)
throw new InvalidOperationException("迭代期间数据已经被改变");

bool ok = true;
if (this.master == null)

{
this.master = this.m_Owner.m_InternalData.GetEnumerator();
ok = this.master.MoveNext();
if( !ok ) return false;
}

DictionaryEntry master_current;
while (ok)

{
master_current = (DictionaryEntry)master.Current;
if (this.slave == null)
slave = m_Owner.GetEnumerator(master_current.Key);
if (slave != null && slave.MoveNext())

{
current = new DictionaryEntry(master_current.Key, slave.Current);
return true;
}
ok = this.master.MoveNext();
slave = null;
}
current = null;
return false;
}

public void Reset()

{
master = null;
slave = null;
current = null;
}

#endregion
}

private class MapValueCollection : ICollection

{
Map m_Owner;
int m_Version;

public MapValueCollection(Map owner)

{
m_Owner = owner;
m_Version = owner.m_Version;
}


ICollection Members#region ICollection Members

public void CopyTo(Array array, int index)

{
foreach (DictionaryEntry ent in this.m_Owner.m_InternalData)

{
ArrayList a = (ArrayList)ent.Value;
if (a != null)

{
a.CopyTo(array, index);
index += a.Count;
}
}
}

public int Count

{

get
{ return m_Owner.Count; }
}

public bool IsSynchronized

{

get
{ return m_Owner.IsSynchronized; }
}

public object SyncRoot

{

get
{ return m_Owner.SyncRoot; }
}


#endregion


IEnumerable Members#region IEnumerable Members

public IEnumerator GetEnumerator()

{
return new MapValueEnumerator(this.m_Owner);
}

#endregion
}

private class MapValueEnumerator : IEnumerator

{
Map m_Owner;
IEnumerator iter;
int version;
object current;

public MapValueEnumerator(Map owner)

{
m_Owner = owner;
version = m_Owner.m_Version;
iter = null;
current = null; // 表示尚未开始:和其他枚举的标志不一样,正好相反
}


IEnumerator Members#region IEnumerator Members
public object Current

{
get

{
if (iter == null)
throw new InvalidOperationException("迭代尚未开始");
if (current == m_Owner)
throw new InvalidOperationException("迭代已经结束");
if (version != m_Owner.m_Version)
throw new InvalidOperationException("迭代期间数据已经被改变");
return current;
}
}

public bool MoveNext()

{
if (version != m_Owner.m_Version)
throw new InvalidOperationException("迭代期间数据已经被改变");
if (current == m_Owner)
throw new InvalidOperationException("迭代已经结束");

if (iter == null)
iter = m_Owner.GetEnumerator();
if (iter.MoveNext())

{
current = ((DictionaryEntry)iter.Current).Value;
return true;
}
else

{
current = m_Owner; // 表示结束
return false;
}
}

public void Reset()

{
iter = null;
current = m_Owner;
}

#endregion
}

#endregion


IDictionary Members#region IDictionary Members

public void Add(object key, object value)

{
MakeKeyExist(key).Add(value);
++m_Count;
}

public void Clear()

{
ParticalClear();
}

public bool Contains(object key)

{
return this.m_InternalData.ContainsKey(key);
}

public IDictionaryEnumerator GetEnumerator()

{
return new MapEnumerator(this);
}

public bool IsFixedSize

{

get
{ return this.m_InternalData.IsFixedSize; }
}

public bool IsReadOnly

{

get
{ return this.m_InternalData.IsReadOnly; }
}

public ICollection Keys

{

get
{ return this.m_InternalData.Keys; }
}

public void Remove(object key)

{
if (this.m_InternalData.ContainsKey(key))

{
ArrayList containor = MakeKeyExist(key);
m_Count -= containor.Count;
++m_Version;
containor.Clear();
m_InternalData.Remove(key);
}
}

public ICollection Values

{

get
{ return new MapValueCollection(this); }
}

public object this[object key]

{
get

{
if (this.m_InternalData.ContainsKey(key))
return this.MakeKeyExist(key)[0];
else
return null;
}

set

{
if (this.m_InternalData.ContainsKey(key))
this.MakeKeyExist(key)[0] = value;
else
this.MakeKeyExist(key).Add(value);
++m_Version;
}
}

#endregion


ICollection Members#region ICollection Members

public void CopyTo(Array array, int index)

{
int i;
ArrayList list;
foreach (DictionaryEntry ent in this.m_InternalData)

{
list = (ArrayList)ent.Value;
for (i = 0; i < list.Count; ++i)
array.SetValue(new DictionaryEntry(ent.Key, list[i]), index++);
}
}

public int Count

{
get

{
#if DEBUG
System.Diagnostics.Debug.Assert(GetCount() == m_Count);
#endif
return m_Count;
}
}

public bool IsSynchronized

{

get
{ return this.m_InternalData.IsSynchronized; }
}

public object SyncRoot

{

get
{ return this.m_InternalData.SyncRoot; }
}


#endregion


IEnumerable Members#region IEnumerable Members

IEnumerator IEnumerable.GetEnumerator()

{
return new MapEnumerator(this);
}

#endregion


IDisposable Members#region IDisposable Members

public void Dispose()

{
ParticalClear();
this.m_InternalData.Clear();
}

#endregion
}


}
【推荐】国内首个AI IDE,深度理解中文开发场景,立即下载体验Trae
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
· 理解Rust引用及其生命周期标识(上)
· 浏览器原生「磁吸」效果!Anchor Positioning 锚点定位神器解析
· 没有源码,如何修改代码逻辑?
· 全程不用写代码,我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了,比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15:你的「微服务管家」又秀新绝活了