一个伪泛型List的实现

// 从一个数组的实现衍生出来的，说是伪泛型，是因为比较的时候是用ToString来比较的，所以只对极少部分的类型有用，真要用到的话，最好限制一下T的范围

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace ConsoleApplication1
{
public class CList<T>
{
/// <summary>
/// 数组增值数
/// </summary>
public const int IncLength = 20;
/// <summary>
/// 字符串数组
/// </summary>
protected T[] list;
/// <summary>
/// 字符串个数
/// </summary>
protected int count;

/// <summary>
/// 空参构造方法
/// </summary>
public CList()
{
this.list = new T[IncLength];
this.count = 0;
}

/// <summary>
/// 以任意个(小于20)字符串参数构造对象的构造方法
/// </summary>
/// <param name="items">变长形参</param>
public CList(params T[] items)
{
list = new T[IncLength];
this.count = 0;
if (items != null && items.Length > 0)
{
int maxLength = 0;
if (items.Length > IncLength)
{
maxLength = IncLength;
}
else
{
maxLength = items.Length;
}
for (int i = 0; i < maxLength; i++)
{
this.list[i] = items[i];
}
this.count = maxLength;
}

}

/// <summary>
/// 在不改变集合当前内容的情况下，使集合容量增加IncLength
/// </summary>
protected void Expend()
{
int newLength = this.list.Length + IncLength;
T[] newList = new T[newLength];
for (int i = 0; i < this.count; i++)
{
newList[i] = this.list[i];
}
this.list = null;
this.list = newList;
}

/// <summary>
/// 只读属性，返回当前集合中的元素个数
/// </summary>
public int Count
{
get
{
return this.count;
}
}

/// <summary>
/// 在集合尾部追加一个元素,若失败抛出Exception
/// </summary>
/// <param name="item">新加入的元素</param>
virtual public void Add(T item)
{
if (this.count == this.list.Length)
{
this.Expend();
}
this.list[this.count] = item;
this.count++;
}

/// <summary>
/// 在集合尾部追加任意个元素，若失败抛出Exception
/// </summary>
/// <param name="items">变长形参</param>
virtual public void Add(params T[] items)
{
if (this.count + items.Length > this.list.Length)
{
this.Expend();
}
for (int i = 0; i < items.Length; i++)
{
this.list[this.count + i] = items[i];
}
this.count += items.Length;
}

/// <summary>
/// 在集合指定位置插入一个元素,若失败抛出Exception
/// </summary>
/// <param name="item">被插入的元素</param>
/// <param name="index">插入位置</param>
virtual public void Insert(T item, int index)
{
if (index < 0)
{
throw new Exception("索引值小于零。");
}
if (this.count == this.list.Length)
{
this.Expend();
}
if (index > this.count)
{
throw new Exception("索引值超出数组长度。");
}
for (int i = this.count; i > index; i--)
{
this.list[i] = this.list[i - 1];
}
this.list[index] = item;
this.count++;
}

/// <summary>
/// 移除指定位置的元素，若失败抛出Exception
/// </summary>
/// <param name="Index"></param>
public void RemoveAt(int Index)
{
if (Index < 0)
{
throw new Exception("索引值小于零。");
}
if (Index >= this.count)
{
throw new IndexOutOfRangeException("索引值大于数组长度。");
}
for (int i = Index; i < this.count - 1; i++)
{
this.list[i] = this.list[i + 1];
}
this.list[this.count - 1] = default(T);
this.count--;
}

/// <summary>
/// 清空集合所有元素
/// </summary>
public void Clear()
{
this.count = 0;
this.list = new T[IncLength];
}

/// <summary>
/// 查找指定字符串aString在集合中的位置(大小写敏感)
/// </summary>
/// <param name="item">被查找的字符串</param>
/// <returns>找到则返回对应位置，未找到返回-1</returns>
virtual public int Find(T t)
{
for (int i = 0; i < this.count; i++)
{
if (this.list[i] != null && this.list[i].Equals(t))
{
return i;
}
}
return -1;
}

/// <summary>
/// 对集合进行排序
/// </summary>
/// <param name="Opt">参数=asc为正向排序，=desc为逆向排序</param>
public void Sort(string Opt = "asc")
{
if (Opt.ToLower() == "asc")
{
for (int i = 0; i < count; i++)
{
for (int j = i + 1; j < count; j++)
{
if (this.list[i].ToString().CompareTo(this.list[j].ToString()) > 0)
{
T temp;
temp = this.list[i];
this.list[i] = this.list[j];
this.list[j] = temp;
}
}
}
}
else
{
for (int i = 0; i < count; i++)
{
for (int j = i + 1; j < count; j++)
{
if (this.list[i].ToString().CompareTo(this.list[j].ToString()) < 0)
{
T temp;
temp = this.list[i];
this.list[i] = this.list[j];
this.list[j] = temp;
}
}
}
}
}

/// <summary>
/// 只读属性，返回集合中字符串长度最大的一项，若存在多项长度相等返回其中的第一项
/// </summary>
public T MaxLenItem
{
get
{
if (this.count == 0)
{
return default(T);
}
if (this.count == 1)
{
return this.list[0];
}
int index = 0;
for (int i = 1; i < this.count; i++)
{
if (this.list[i].ToString().Length > this.list[i - 1].ToString().Length)
{
index = i;
}
}
return this.list[index];
}
}

/// <summary>
/// 只读属性，返回集合中字符串长度最小的一项，若存在多项长度相等返回其中的第一项
/// </summary>
public T MinLenItem
{
get
{
if (this.count == 0)
{
return default(T);
}
if (this.count == 1)
{
return this.list[0];
}
int index = 0;
for (int i = 1; i < this.count; i++)
{
if (this.list[i].ToString().Length < this.list[i - 1].ToString().Length)
{
index = i;
}
}
return this.list[index];
}
}

/// <summary>
/// 按位置输出集合中的各项元素,输出格式为：
///
/// 集合中共有？个元素，分别为：
/// 元素1
/// 元素2
/// ……
/// 元素n
/// </summary>
public void Show()
{
if (this.count == 0)
{
Console.WriteLine("集合中没有元素。");
return;
}
Console.WriteLine("集合中共有{0}个元素，分别为：", this.count);
for (int i = 0; i < this.count; i++)
{
Console.WriteLine("元素{0}：{1}", i, this.list[i]);
}
}
}

public class CMyDirectory<T> : CList<T>
{
/// <summary>
/// 检查字符串数组参数strArr中是否包含重复数据项（大小写不敏感）
/// </summary>
/// <param name="strArr">被检查的字符串数据</param>
/// <returns>true:不包含重复项；false：包含重复项</returns>
public bool IsValid(T[] strArr)
{
if (strArr.Length <= 1)
{
return false;
}
List<T> list = new List<T>();
list.Add(strArr[0]);
for (int i = 1; i < strArr.Length; i++)
{
foreach (var s in list)
{
if (s.ToString().ToLower() == strArr[i].ToString().ToLower())
{
return true;
}
}
list.Add(strArr[i]);
}
return false;
}

/// <summary>
/// 集合尾部添加一个新元素，且不能和已有元素重复（大小写不敏感）
/// </summary>
/// <param name="item">追加的新元素</param>
public override void Add(T item)
{
bool contained = false;
if (this.count == this.list.Length)
{
this.Expend();
}
for (int i = 0; i < this.count; i++)
{
if (this.list[i].ToString().ToLower() == item.ToString().ToLower())
{
contained = true;
break;
}
}
if (!contained)
{
base.Add(item);
}
}

/// <summary>
/// 集合尾部添加若干个新元素，且不能和已有元素重复（大小写不敏感）
/// </summary>
/// <param name="items">追加的新元素</param>
public override void Add(params T[] items)
{
if (this.count + items.Length > this.list.Length)
{
this.Expend();
}
for (int i = 0; i < items.Length; i++)
{
if (this.count == 0) {
base.Add(items[i]);
continue;
}
bool contained = false;
for (int j = 0; j < this.count; j++)
{
if (this.list[j].ToString().ToLower() == items[i].ToString().ToLower())
{
contained = true;
break;
}
}
if (!contained)
{
base.Add(items[i]);
}
}
}

/// <summary>
/// 在指定的位置插入一个新元素，且不能和已有元素重复（大小写不敏感）
/// </summary>
/// <param name="item">插入的新元素</param>
/// <param name="index">插入位置</param>
public override void Insert(T item, int index)
{
bool contained = false;
if (this.count == this.list.Length)
{
this.Expend();
}
for (int i = 0; i < this.count; i++)
{
if (this.list[i].ToString().ToLower() == item.ToString().ToLower())
{
contained = true;
break;
}
}
if (!contained)
{
base.Insert(item, index);
}
}

/// <summary>
/// 查找一个指定元素在集合中的位置（大小写不敏感）。
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public override int Find(T t)
{
for (int i = 0; i < this.count; i++)
{
if (this.list[i].ToString().ToLower() == t.ToString().ToLower())
{
return i;
}
}
return -1;
}
}
}