泛型集合类型，赋予集合业务意义，增强集合的抽象使用

//集合基类：

public abstract class CollectionBase<T> : IList<T>
{
    private IList<T> list;
    public List<T> Instance
    {
        get { return (List<T>)this.list; }
    }

    public CollectionBase()
    {
        list = new List<T>();
    }

    #region IList<T> 成员

    public int IndexOf(T item)
    {
        return this.list.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        this.list.Insert(index, item);
    }

    public void RemoveAt(int index)
    {
        this.list.RemoveAt(index);
    }

    public T this[int index]
    {
        get
        {
            return this.list[index];
        }
        set
        {
            this.list[index] = value;
        }
    }

    #endregion

    #region ICollection<T> 成员

    public void Add(T item)
    {
        this.list.Add(item);
    }

    public void Clear()
    {
        this.list.Clear();
    }

    public bool Contains(T item)
    {
        return this.list.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        this.list.CopyTo(array, arrayIndex);
    }

    public int Count
    {
        get { return this.list.Count; }
    }

    public bool IsReadOnly
    {
        get { return this.list.IsReadOnly; }
    }

    public bool Remove(T item)
    {
        return this.list.Remove(item);
    }

    #endregion

    #region IEnumerable<T> 成员

    public IEnumerator<T> GetEnumerator()
    {
        return this.list.GetEnumerator();
    }

    #endregion

    #region IEnumerable 成员

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

    #endregion
}

我们在使用这个类的时候就必须遵循一定的游戏规则，也就是我们在子类中所有可能用到集合本身的时候，我们必须用base.Instance来获得集合的句柄，这一点尤为重要，其实这很简单，就像我们的在一个类中定义了一个List<T>的对象，并对它进行操作一样，只不过这个过程被我们集中起来了。

//例子：

public sealed class SampleCollectionFromCollectionBase : CollectionBase<Sample>
{
    //Other logic code which you will implement
    public override string ToString()
    {
        string result = string.Empty;
        foreach (Sample s in base.Instance)
        {
            result = result + s.Value + " ";
        }
        return result;
    }
}

我们刚才一直在谈到的相同句柄的问题是否开始有些担心“串音”的现象发生，因为我们知道一个泛型类的实例决定于它的类型T，相同的T类型将只会有一个静态副本的类。不过你应该注意到只是静态类副本，而不是静态对象对象副本，每个类实例将拥有自己的对象，并在堆中有着自己的引用，这些引用是毫无交叉的。因此，即使两个类都继承自一个父类，各自的base也会是不同的，而不是有所关联。不过为了消除您的顾虑，我还是尽可能为你提供看得见的“说明”，我们用一个简单的测试来证实我们分析的结果：

在上面的例子类中，我们补充一个InstanceTest的方法：

    /// <summary>
    /// Only a Test
    /// </summary>
    public void InstanceTest()
    {
        base.Add(new Sample("(new SampleCollectionFromCollectionBase).base.Add()"));
        base.Instance.Add(new Sample("(new SampleCollectionFromCollectionBase).base.Instance.Add()"));
    }

并且再写一个类，也用base去调用它的Instance，其实说白了，写一个和上面的SampleCollectionFromCollectionBase 相同的类，并让类型有所不同就可以了。如果我们的Instance会“串音”的话，我们就会看到在类似下面的代码执行后会是两套完全一样的结果：

SampleCollectionFromCollectionBase sc3 = new SampleCollectionFromCollectionBase();
SampleCollectionFromCollectionBase sc3_1 = new SampleCollectionFromCollectionBase();
SampleCollection2FromCollectionBase sc4 = new SampleCollection2FromCollectionBase();
sc3.InstanceTest();
sc3_1.InstanceTest();
sc4.InstanceTest();
foreach (Sample s in sc3.Instance)
{
    Console.WriteLine(s.Value);
}
foreach (Sample s in sc3_1.Instance)
{
    Console.WriteLine(s.Value);
}
foreach (Sample s in sc4.Instance)
{
    Console.WriteLine(s.Value);
}

理由很简单，因为不论sc3、sc3_1或者sc4，都引用自同一个Instance？！？！？

当然了，事实不是这样的，下面就是这段程序的执行结果：

(new SampleCollectionFromCollectionBase).base.Add()
(new SampleCollectionFromCollectionBase).base.Instance.Add()
(new SampleCollectionFromCollectionBase).base.Add()
(new SampleCollectionFromCollectionBase).base.Instance.Add()
(new SampleCollection2FromCollectionBase).base.Add()
(new SampleCollection2FromCollectionBase).base.Instance.Add()

很容易看出第1、2行是sc3，第3、4行是sc3_1，第5、6行是sc4的结果。（您别像我这样写测试的代码，因为我的测试代码貌似管的范围有点多了，测试应该尽量执行单一的功能。）
源代码下载：CA_CollectionBase.rar

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1776519