1.普通集合
实现一个string类型的集合，可以添加string类型元素和根据索引读取基本功能。
1 internal class Program
2 {
3 static void Main(string[] args)
4 {
5 ArrayStr arrayStr = new ArrayStr();
6 arrayStr.Add("1");
7 arrayStr.Add("2");
8 string name = arrayStr[0];
9 Console.WriteLine(name);
10 }
}
11
12 //定义string类型集合
13 public class ArrayStr
14 {
15
16 public ArrayStr()
17 {
18 _items = new string[1]; //初始化
19 }
20
21 private string[] _items;
22
23 private int _count;
24
25 public int Count
26 {
27 get { return _count; }
28 }
29
30 public void Add(string item)
31 {
32 _items[_count] = item;
33 _count++;
34
35 string[] temp = new string[_items.Length + 1]; //动态扩容
36 for (int i = 0; i < _items.Length; i++)
37 {
38 temp[i] = _items[i]; //扩容后拷贝
39 }
40 _items = temp;
41 }
42
43 public string this[int index]
44 {
45 get { return _items[index]; }
46 set { _items[index] = value; }
47 }
48 }
49
50
但是如果要处理int 类型或其他的元素，是不是应该再实现一个int类型集合或其他类型集合，这时候如果实现一个Object类型集合，就是可以兼容多种类型数据。
2.Object集合
1 internal class Program
2 {
3 static void Main(string[] args)
4 {
5 //引用
6 ArrayObject arrayObject = new ArrayObject();
7 arrayObject.Add("1"); //装箱
8 arrayObject.Add(2); //装箱
9 string name = (string)arrayObject[0]; //拆箱
10 int key = (int)arrayObject[1]; //拆箱
11
12 Console.WriteLine(key + ":" + name);
13 Console.ReadKey();
14 }
}
15
16 //定义object类型集合
17 internal class ArrayObject
18 {
19 public ArrayObject()
20 {
21 _items = new object[1]; //初始化
22 }
23
24 private object[] _items;
25
26 private int _count;
27
28 public int Count
29 {
30 get { return _count; }
31 }
32
33 public void Add(object item)
34 {
35 _items[_count] = item;
36 _count++;
37
38 object[] temp = new object[_items.Length + 1]; //动态扩容
39 for (int i = 0; i < _items.Length; i++)
40 {
41 temp[i] = _items[i]; //扩容后拷贝
42 }
43 _items = temp;
44 }
45
46 public object this[int index]
47 {
48 get { return _items[index]; }
49 set { _items[index] = value; }
50 }
51
52 53
54 }
虽然实现了可以支持不同类型数据的集合，但是我们看使用这个集合的时候，每次都要进行类型转换，就是我们所说拆箱和装箱的行为。而且如果对集合进行了多处写入了不同类型，那在读数据的时候强转类型的时候就会报错，那还得进行类型判断之后再转换，这两点就足够麻烦了。所以下面看看实现泛型集合，是否可以解决这些问题。
3.泛型集合
1 internal class Program
2 {
3 static void Main(string[] args)
4 {
5 //使用
6 ArrayList<string> arrayObject = new ArrayList<string>();
7 arrayObject.Add("泛型");
8
9 string name = arrayObject[0];
10
11
12 Console.WriteLine(name);
13 Console.ReadKey();
14 }
15 }
16 //泛型集合
17 internal class ArrayList<T>
18 {
19 public ArrayList()
20 {
21 _items = new T[1]; //初始化
22 }
23
24 private T[] _items;
25
26 private int _count;
27
28 public int Count
29 {
30 get { return _count; }
31 }
32
33 public void Add(T item)
34 {
35 _items[_count] = item;
36 _count++;
37
38 T[] temp = new T[_items.Length + 1]; //动态扩容
39 for (int i = 0; i < _items.Length; i++)
40 {
41 temp[i] = _items[i]; //扩容后拷贝
42 }
43 _items = temp;
44 }
45
46 public T this[int index]
47 {
48 get { return _items[index]; }
49 set { _items[index] = value; }
50 }
51
52 }
在使用的时候就开始声明类型，在写入的时候那就对类型有约束了，不会写入其他类型，并且读数据时候可以直接用该类型来接收，最重要的是可以实现不同类型的集合功能。
4.总结
这个就是泛型的作用，这里举例的是实现支持不同类型元素的集合功能，现实代码中可能有通用的处理数据方法或者类，接口等都可以用泛型来支持不同类型参数，而我们只需要写一个方法或类。它从广泛角度上来讲就是一个类似公司的合同模板，每位员工的劳动合同模板都是一样，员工就是不同类型。.net提供了泛型这一特性，就是相当于提供了一个代码模板，对于开发过程中可以便捷很多，在实际编译代码的时候，系统会将模板中的比如T的类型占位，替换成实际的类型，再进行编译。
标签：count,string,int,items,集合,理解,泛型,public From： https://www.cnblogs.com/morehappy/p/16827780.html