怎样自定义自己的Collection?? (有答必结~)

Question

想定义个 TableHeaderList 集合类型, 它的元素是TableHeader(一个自定义的类), 
TableHeaderList 继承了 ICollection, 
但它要我实现:
System.Collections.ICollection.CopyTo(System.Array, int)
System.Collections.ICollection.IsSynchronized
System.Collections.ICollection.SyncRoot
System.Collections.IEnumerable.GetEnumerator()
不知道怎么去实现??到底要怎么做才能自定义出自己的集合类型, 然后用 coll[i] 或 coll["name"]就可以访问到里面的元素???

Answer 1

http://community.csdn.net/Expert/topic/5045/5045049.xml?temp=.7106897
借点人气 找人帮帮忙

Answer 2

给你个例子
using System;
using System.Collections;
namespace IBatisNet.DataMapper.Test.Domain 
{
public class AccountCollection : CollectionBase 
{
public AccountCollection() {} public Account this[int index] 
{
get { return (Account)List[index]; }
set { List[index] = value; }
} public int Add(Account value) 
{
return List.Add(value);
} public void AddRange(Account[] value) 
{
for (int i = 0; i < value.Length; i++) 
{
Add(value[i]);
}
} public void AddRange(AccountCollection value) 
{
for (int i = 0; i < value.Count; i++) 
{
Add(value[i]);
}
} public bool Contains(Account value) 
{
return List.Contains(value);
} public void CopyTo(Account[] array, int index) 
{
List.CopyTo(array, index);
} public int IndexOf(Account value) 
{
return List.IndexOf(value);
}

public void Insert(int index, Account value) 
{
List.Insert(index, value);
}

public void Remove(Account value) 
{
List.Remove(value);
}
}
}

Answer 3

给出一个基于Hashtable的集合实现参考：
using System;
using System.Collections;
namespace Test
{
public class MyCollection : IDictionary, ICollection, IEnumerable, ICloneable
{
protected Hashtable innerHash;

#region "Constructors"
public  MyCollection()
{
innerHash = new Hashtable();
}

public MyCollection(MyCollection original)
{
innerHash = new Hashtable (original.innerHash);
}

public MyCollection(IDictionary dictionary)
{
innerHash = new Hashtable (dictionary);
}

public MyCollection(int capacity)
{
innerHash = new Hashtable(capacity);
}

public MyCollection(IDictionary dictionary, float loadFactor)
{
innerHash = new Hashtable(dictionary, loadFactor);
}

public MyCollection(IHashCodeProvider codeProvider, IComparer comparer)
{
innerHash = new Hashtable (codeProvider, comparer);
}

public MyCollection(int capacity, int loadFactor)
{
innerHash = new Hashtable(capacity, loadFactor);
}

public MyCollection(IDictionary dictionary, IHashCodeProvider codeProvider, IComparer comparer)
{
innerHash = new Hashtable (dictionary, codeProvider, comparer);
}

public MyCollection(int capacity, IHashCodeProvider codeProvider, IComparer comparer)
{
innerHash = new Hashtable (capacity, codeProvider, comparer);
}

public MyCollection(IDictionary dictionary, float loadFactor, IHashCodeProvider codeProvider, IComparer comparer)
{
innerHash = new Hashtable (dictionary, loadFactor, codeProvider, comparer);
}

public MyCollection(int capacity, float loadFactor, IHashCodeProvider codeProvider, IComparer comparer)
{
innerHash = new Hashtable (capacity, loadFactor, codeProvider, comparer);
}
#endregion #region Implementation of IDictionary
public MyCollectionEnumerator GetEnumerator()
{
return new MyCollectionEnumerator(this);
}
        
System.Collections.IDictionaryEnumerator IDictionary.GetEnumerator()
{
return new MyCollectionEnumerator(this);
}

IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}

public void Remove(string key)
{
innerHash.Remove (key);
}

void IDictionary.Remove(object key)
{
Remove ((string)key);
}

public bool Contains(string key)
{
return innerHash.Contains(key);
}

bool IDictionary.Contains(object key)
{
return Contains((string)key);
}

public void Clear()
{
innerHash.Clear();
}

public void Add(string key, MyType value)
{
innerHash.Add (key, value);
}

void IDictionary.Add(object key, object value)
{
Add ((string)key, (MyType)value);
}

public bool IsReadOnly
{
get
{
return innerHash.IsReadOnly;
}
}

public MyType this[string key]
{
get
{
return (MyType) innerHash[key];
}
set
{
innerHash[key] = value;
}
}

object IDictionary.this[object key]
{
get
{
return this[(string)key];
}
set
{
this[(string)key] = (MyType)value;
}
}
        
public System.Collections.ICollection Values
{
get
{
return innerHash.Values;
}
}

public System.Collections.ICollection Keys
{
get
{
return innerHash.Keys;
}
}

public bool IsFixedSize
{
get
{
return innerHash.IsFixedSize;
}
}
#endregion

#region Implementation of ICollection

public void CopyTo(System.Array array, int index)
{
innerHash.CopyTo (array, index);
}

public bool IsSynchronized
{
get
{
return innerHash.IsSynchronized;
}
}

public int Count
{
get
{
return innerHash.Count;
}
}

public object SyncRoot
{
get
{
return innerHash.SyncRoot;
}
}
#endregion

#region Implementation of ICloneable

public MyCollection Clone()
{
MyCollection clone = new MyCollection();
clone.innerHash = (Hashtable) innerHash.Clone();

return clone;
}

object ICloneable.Clone()
{
return Clone();
}
#endregion

#region "HashTable Methods"

public bool ContainsKey (string key)
{
return innerHash.ContainsKey(key);
}

public bool ContainsValue (MyType value)
{
return innerHash.ContainsValue(value);
}

public static MyCollection Synchronized(MyCollection nonSync)
{
MyCollection sync = new MyCollection();
sync.innerHash = Hashtable.Synchronized(nonSync.innerHash); return sync;
}
#endregion internal Hashtable InnerHash
{
get
{
return innerHash;
}
}
}

public class MyCollectionEnumerator : IDictionaryEnumerator
{
private IDictionaryEnumerator innerEnumerator;

internal MyCollectionEnumerator (MyCollection enumerable)
{
innerEnumerator = enumerable.InnerHash.GetEnumerator();
}

#region Implementation of IDictionaryEnumerator
public string Key
{
get
{
return (string)innerEnumerator.Key;
}
}

object IDictionaryEnumerator.Key
{
get
{
return Key;
}
}

public MyType Value
{
get
{
return (MyType)innerEnumerator.Value;
}
}

object IDictionaryEnumerator.Value
{
get
{
return Value;
}
}

public System.Collections.DictionaryEntry Entry
{
get
{
return innerEnumerator.Entry;
}
}
#endregion

#region Implementation of IEnumerator
public void Reset()
{
innerEnumerator.Reset();
}

public bool MoveNext()
{
return innerEnumerator.MoveNext();
}

public object Current
{
get
{
return innerEnumerator.Current;
}
}
#endregion
}
}

Answer 4

Account是自定义类，AccountCollection是Account的集合

Answer 5

只要在你的TableHeaderList 定义一个arraylist就行了
然后
public TableHeader this[i]
{
     get
     {
          return (TableHeader)arraylist[i];
     }
     set
     {
          arraylist[i] = value;
     }
}

Answer 6

定义一下索引器（indexers),用来提供索引功能。coll[i] 或 coll["name"]就可以访问到里面的元素了。查下msdn好了，有详细定义例子。

Answer 7

关于CollectionBase
为强类型集合提供抽象基类。线程安全
此类型的公共静态成员对于多线程操作是安全的。不能保证实例成员是线程安全的。此实现不为 CollectionBase 提供同步（线程安全）的包装，但派生类可以使用 SyncRoot 属性创建各自的 CollectionBase 同步版本。通过集合枚举在本质上不是一个线程安全的过程。甚至在对集合进行同步处理时，其他线程仍可以修改该集合，这会导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。备注
CollectionBase 实例始终是可修改的。有关此类的只读版本，请参见 ReadOnlyCollectionBase。对实施者的说明:  提供此基类旨在使实施者创建强类型自定义集合变得更容易。实施者应扩展此基类，而不应创建自己的基类。