C# -- 泛型

泛型的概念--“通过参数化类型来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化，从而实现灵活的复用”

BubbleSort定义成泛型类 定义泛型类的一种方法是在类后面加上“<T>” 

 //定义泛型类SortHelper 这里“where T:IComparable” 是给类型参数T一个限制 -- 参数类型必须实现IComparable接口，否则无法通过编译    public class SortHelper<T> where T:IComparable    {        public void BubbleSort(T[] arr)        {            int length = arr.Length;            for (int i = 0; i < length-1; i++)            {                for (int j = 0; j < length-1-i; j++)                {                    if (arr[j].CompareTo(arr[j+1])>0)                    {                        T temp = arr[j];                        arr[j] = arr[j + 1];                        arr[j + 1] = temp;                    }                }            }        }    }

public class cat:IComparable    {        public string name;        public int price;        public int CompareTo(object obj)        {            cat catT = (cat)obj;            return this.price.CompareTo(catT.price);        }        public cat(string name, int price)        {            this.price = price;            this.name = name;        }    }

 static void Main(string[] args)        {            SortHelper<byte> sorter = new SortHelper<byte>();            byte[] a = { 4,5,1,3,2,8,5,0,2};            sorter.BubbleSort(a);            SortHelper<int> sorter1 = new SortHelper<int>();            int[] b = { 4, 5, 1, 3, 2, 8, 5, 0, 2 };            sorter1.BubbleSort(b);

            SortHelper<cat> sorter2 = new SortHelper<cat>();            cat cat1=new cat("猫1",1000);            cat cat2=new cat("猫2",1400);            cat cat3=new cat("猫3",400);            cat[] c = { cat1, cat2, cat3 };            sorter2.BubbleSort(c);

　　　　　　　//输出省略        }

IEnumerable<T>接口的IEnumerator<T> GetEnumerator()方法返回了一个迭代器 ，不难发现T如果用 out 标记，则T代表了输出，也就说只能作为结果返回。
IComparable<T>接口的CompareTo(T other)方法传入了一个T类型的Other参数，不难发现T如果用 in 标记，则T代表了输入，也就是它只能作为参数传入。
为了在foreach中使用 People的实例， 我们给People实现IEnumerable接口，代码如下：

public class People:IEnumerable    {        private Person[] _people;        public People(Person[] pArray)        {            //实例化数组 用于存Person实例            _people = new Person[pArray.Length];            for (int i = 0; i < pArray.Length; i++)            {                _people[i] = pArray[i];            }        }////IEnumerable和IEnumerator通过IEnumerable的GetEnumerator()方法建立了连接，可以通过IEnumerable的GetEnumerator()得到IEnumerator对象。        IEnumerator IEnumerable.GetEnumerator()        {            return (IEnumerator)GetEnumerator();        }        public PeopleEnum GetEnumerator()        {            return new PeopleEnum(_people);        }    }    public class PeopleEnum:IEnumerator    {        public Person[] _people;        public PeopleEnum(Person [] pArray)        {            _people = pArray;        }        //游标        int position = -1;        //是否可以往下 移        public bool MoveNext()        {            position++;            return (position < _people.Length);        }        //集合的所有元素取完了之后 重置position        public void Reset()        {            position = -1;        }        //实现 IEnumerator的 Current方法 返回当前所指的Person对象        object IEnumerator.Current        {            get            {                return Current;            }        }        //Current是返回Person类实例的只读方法        public Person Current        {            get            {                try                {                    return _people[position];                }                catch (IndexOutOfRangeException)                {                    throw new InvalidOperationException();                }            }        }    }

static void Main(string[] args)        {            Person[] personArray = new Person[3]{            new Person("Keiling1"),            new Person("Keiling2"),            new Person("Keiling3"),            };            People people = new People(personArray);            foreach (Person item in people)            {                Console.WriteLine(item.name);            }        }

1.一个集合要支持foreach方式的遍历，必须实现IEnumerable接口，描述这类实现了该接口的对象，我们叫它 ‘序列’。
比如 List<T> 支持 foreach 遍历 是因为它实现了IEnumerable接口和其泛型版，
2. IEnumerator对象具体实现了迭代器（通过MoveNext()，Reset()，Current）。

3. 从这两个接口的用词选择上，也可以看出其不同：IEnumerable是一个声明式的接口，声明实现该接口的class是“可枚举（enumerable）”的，但并没有说明如何实现迭代器，
而IEnumerator是一个实现式的接口，IEnumerator对象就是一个迭代器。 
4.由于IEnumerable<T>继承了IEnumerable接口，所以要实现IEnumerator<T> ，还需要实现IEnumerator接口，由于和泛型版本的方法同名，所以该方法的实现需要使用显式接口实现。这里就不继续介绍它的具体实现了，和IEnumerator基本一致，这里就不详述了，读者可以自己动手写一下。