20.C# 创建自己的泛型类型

1.定义泛型类

可以使用以下语法创建泛型类，T可以是任意符合C#标识符命名规范的任意标识符

class MyGenericClass<T>
{
 //....
}

泛型类可以包含任意多个类型，使用逗号隔开。定义了这些类型之后就可以像其他类型一样使用它们，比如用作成员变量的类型，属性或方法的返回值，方法的参数类型等等。如下把T1用作成员变量的类型、属性的返回值，方法的参数类型。

    class MyGenericClass<T1, T2, T3>
    {
        private T1 innerT1Object;

        public MyGenericClass()
        { 

        }

        public MyGenericClass(T1 t)
        {
            innerT1Object = t;
        }

        public T1 InnerT1Object
        {
            get { return innerT1Object; }
        }

    }

注：不能使用定义的类型T来创建它的对象，因为T可能是抽象类，或者没有公共的构造函数。我们唯一可以假设的是T是继承于System.Object的类型，只能使用Object类提供的方法。

如下代码是不能编译的

    class MyGenericClass<T1, T2, T3>
    {
        private T1 innerT1Object;

        public MyGenericClass()
        {
            innerT1Object = new T1();
        }

        public MyGenericClass(T1 t)
        {
            innerT1Object = t;
        }

        public T1 InnerT1Object
        {
            get { return innerT1Object; }
        }

    }

也不能用+、-、==、!=等运算符比较两个T对象，因为该对象可能不支持这个运算符，但可以用==和！==比较T对象和null

        public bool Compare(T1 op1,T2 op2)
        {
            if (op1 != null && op2 != null)//正确
                return true;
            else
                return false;
        }

        public bool Compare(T1 op1, T2 op2)
        {
            if (op1 == op2)//错误
                return true;
            else
                return false;
        }

1.1Default关键字

因为不知道T类型是什么类型，所以就不好为T类型的变量赋值，但可以使用default为T类型的变量赋值，它可以根据T的具体类型赋予默认值，比如引用类型赋值null，int赋予0

        public MyGenericClass()
        {
            innerT1Object = default(T1);
        }

1.2约束

前面定义的泛型类型称为无绑定类型，因为没有对它们进行任何约束。可以使用约束把T类型限制为某个类或者继承于某个具体的类。

使用where 关键字约束泛型，可以有多个约束，多个约束直接用逗号隔开，也可以有多个where用于约束不同的类型，where约束必须写在继承的类或接口后面

class MyGenericClass<T1,T2>：IMyInterface where T1:Constraint1，Constraint2 where T2:Constraint3

下表列出了一些可用的约束

约束	定义
struct	T必须是值类型，比如int，结构等
class	T必须是引用类型，比如string、类
base-class	T是某个类型或者继承于某个类型，使用时用具体的类名替代，比如T：Animal
interface	T是某个接口或者继承了某个接口，如T:IMyInterface
new()	T必须有无参数的公共构造函数，如果new()用做约束，它必须是为类型T指定的最后一个约束

如下例子示范了struct、class、base-class约束的使用。因为T1约束为值类型，所以定义泛型变量时T1只能是int等值类型，T2约束为引用类型，所以第二个参数类型必须是引用类型，T3使用base-class约束把T3约束为Animal或者继承于Animal的类。

class MyGenericClass<T1, T2, T3> where T1:struct where T2:class where T3:Animal
{
}

MyGenericClass<int, string, Cow> generic = new MyGenericClass<int, string, Cow>();

可用通过base-class约束把一个类型用做另一个类型的约束，这称为裸类型约束，表示两个参数类型是同一个类型，或者继承于另一个类型

 class MyGenericClass<T1, T2, T3> where T1:T2
 {
 }

但是约束不能循环，如下定义是不能编译的

    class MyGenericClass<T1, T2, T3> where T1:T2 where T2:T1
    {
    }

约束可以是接口类型，表示T是该接口类型或者实现了这个这个接口，如果使用了new()约束，new()约束要放在每个where的最后

    class MyGenericClass<T1, T2, T3> where T1:MyInterface ,new() where T2:class
    {
    }

创建泛型类实例

abstract class Animal
    {
        protected string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public Animal()
        {
            name = "The animal has no name.";
        }

        public Animal(string newName)
        {
            name = newName;
        }

        public void Feed()
        {
            Console.WriteLine("{0}has been fed.", name);
        }

        public abstract void MakeANoise();

    }

class Cow : Animal
    {
        public void Milk()
        {
            Console.WriteLine("{0}has been milked.", name);
        }

        public Cow(string newName)
            : base(newName)
        {

        }

        public override void MakeANoise()
        {
            Console.WriteLine("{0} say 'moo'",name);
        }
    }

    class Chicken : Animal {
        public void LagEgg()
        {
            Console.WriteLine("{0}has lag en egg.", name);
        }

        public Chicken(string newName)
            : base(newName)
        { 

        }

        public override void MakeANoise()
        {
            Console.WriteLine("{0} say 'Cluck'", name);
        }
    }

    class SuperCow : Cow
    {
        public SuperCow(string name)
            : base(name)
        { 

        }

        public void Fly()
        {
            Console.WriteLine("{0} is flying", name);
        }

        public override void MakeANoise()
        {
            Console.WriteLine("{0} say 'here i come to save the world'", name);
        }
    }

    class Farm<T>:IEnumerable<T> where T : Animal
    {
        private List<T> animals = new List<T>();
        public List<T> Animails
        {
            get { return animals; }
        }

        public void MakeNoises()
        {
            foreach (T animal in animals)
            {
                animal.MakeANoise();
            }
        }

        public void FeedTheAnimals()
        {
            foreach (T animal in animals)
            {
                animal.Feed();
            }
        }

        public Farm<Cow> GetCows()
        {
            Farm<Cow> cows = new Farm<Cow>();
            foreach (T animal in animals)
            {
                if (animal is Cow)
                    cows.Animails.Add(animal as Cow);
            }

            return cows;
        }

        //实现IEnumerable<T>接口用于迭代Farm<T>集合，实现该接口，需要实现下面两个方法
        public IEnumerator<T> GetEnumerator()
        {
            return animals.GetEnumerator();
        }

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

    class Program
    {

        static void Main(string[] args)
        {
            Farm<Animal> farm = new Farm<Animal>();
            farm.Animails.Add(new Cow("Jack"));
            farm.Animails.Add(new Chicken("Vera"));
            farm.Animails.Add(new Chicken("Sally"));
            farm.Animails.Add(new SuperCow("Kavin"));
            farm.MakeNoises();

            Farm<Cow> cowFarm = farm.GetCows();
            foreach (Cow cow in cowFarm)
            {
                if (cow is SuperCow)
                    (cow as SuperCow).Fly();

            }

            Console.ReadLine();
        }
    }

该实例通过在内部利用List<T>泛型类实现自己的泛型类型，并实现IEnumerable<T>接口迭代集合。

注：上面的泛型类继承了IEnumerable<T>，在Farm<T>提供的约束也会应用在IEnumerable<T>上。如果在基类上也定义了约束，则子类不能解除约束，也就是说类型T在子类必须受至少到与基类相同的约束。

子类不能解除约束的意思是：如果子类没有约束，必须要在子类的定义中显式把父类的约束写出来。假如有一个子类SuperFarm<T>继承了Fram<T>类，它没有自己的约束，因为基类Farm<T>约束了T必须为Animal，所以子类定义时必须把这个约束显式写出

    //正确
    class SuperFarm<T> : Farm<T> where T:Animal
    { 

    }
    //错误
    class SuperFarm<T> : Farm<T>
    { 

    }

如果子类有自己的约束，则子类的约束必须是父类的约束的一个子集，或者说子类约束中的对象必须能隐式转换为父类约束中的对象。如下约束T为Cow，Cow是Animal的一个子类，可以隐式转换为Animal。

    class SuperFarm<T> : Farm<T> where T:Cow
    { 

    }

如果一个类继承了泛型类，且改类不是泛型类，则它必须明确给出所有必须的类型信息，比如

    //正确
    class SuperFarm : Farm<Cow>
    { 

    }

    //错误的，没有给出类型T的具体类型信息
    class SuperFarm : Farm<T>
    { 

    }

1.3泛型运算符

与其他类一样，泛型类可以对运算符进行重载。例如我们可以在Fram<T>中重载如下运算符，这样我们就能计算Farm<Animal> newFarm=farm+cowFarm这里的类型，其中cowFarm是Farm<Cow>的实例，farm是Farm<Animal>的实例，使用隐式转换运算符，我们就能把cowFarm隐式转换为List<Animal>类型，进而利用第二个运算符进行计算。

        public static implicit operator List<Animal>(Farm<T> farm)
        {
            List<Animal> result = new List<Animal>();
            foreach (T animal in farm)
            {
                result.Add(animal);
            }

            return result;
        }

        public static Farm<T> operator +(Farm<T> farm1, List<T> farm2)
        {
            Farm<T> result=new Farm<T> ();

            foreach(T animal in farm1)
            {
                result.Animails.Add(animal);
            }

            foreach(T animal in farm2)
            {
                if(!result.Contains(animal))
                    result.animals.Add(animal);
            }

            return result;
        }

第二个运算符中，第一个参数必须为Farm<T>类型，第二个参数必须为List<T>类型，为了使Farm<Animal> newFarm=cowFarm+farm能计算，再添加一个运算符，这个运算符利用了现有的运算符。

        public static Farm<T> operator +(List<T> farm1, Farm<T> farm2)
        {
            return farm2 + farm1;
        }

有人说利用下面这个运算符也能实现Farm<Animal> newFarm=cowFarm+farm的运算

        public static Farm<T> operator +(Farm<T> farm1, Farm<T> farm2)
        {
            Farm<T> result = new Farm<T>();

            foreach (T animal in farm1)
            {
                result.Animails.Add(animal);
            }

            foreach (T animal in farm2)
            {
                if (!result.Contains(animal))
                    result.animals.Add(animal);
            }

            return result;
        }

事实上这是不行的，因为Farm<Animal>和Farm<Cow>是不同的类型，他们不能进行计算。要使上面的式子能计算，必须重载隐式转换运算符，把Farm<Cow>转换为Farm<Animal>

        public static implicit operator Farm<Animal>(Farm<T> farm)
        {
            Farm<Animal> result = new Farm<Animal>();
            foreach (T animal in farm)
            {
                result.animals.Add(animal);
            }

            return result;
        }

从上面的例子可以看出，泛型中，如果类型T是继承的关系，一般都把子类转换为最基本的父类然后进行运算。

2.泛型结构

可以用与类类似的方式，定义泛型结构，只不过结构是值类型。

    public struct MyStruct<T1, T2>
    {
        public T1 item1;
        public T2 item2;
    }

 3.泛型接口

泛型接口的定义和类一样，下面的泛型接口中T用作方法AttemptToBreed的参数类型和属性OldestInHerd的返回类型。

    interface MyInterface<T> where T : Animal
    {
        bool AttemptToBreed(T animal1, T animal2);
        T OldestInHerd { get; }
    }

4.泛型方法

之前的例子中有一个GetCow方法，假如我们需要再获取Chicken的集合，是不是需要再写一个方法，这样太麻烦了，泛型方法可以很好的解决这个问题。

        public Farm<Cow> GetCows()
        {
            Farm<Cow> cows = new Farm<Cow>();
            foreach (T animal in animals)
            {
                if (animal is Cow)
                    cows.Animails.Add(animal as Cow);
            }

            return cows;
        }

泛型方法的标准是方法声明中有个尖括号，中间是类型符T，比如我们可以添加一个泛型方法解决刚刚的问题。

        public Farm<U> GetSpecies<U>() where U:T
        {
            Farm<U> result = new Farm<U>();
            foreach (T animal in animals)
            {
                if (animal is U)
                    result.animals.Add(animal as U);
            }

            return result;
        }

注：泛型方法的类型参数不能用和Farm<T>相同的类型参数标识符，即Farm<T>用T做类型参数标识符，泛型方法就不能用T，因为它们表示的含义不一样。个人理解是Farm<T>是该类能处理的类型，GetSpecies<U>中的U是泛型方法能处理的类型，T和U可能没有半点联系。如可以在Farm<T>类中定义，如下方法，该泛型方法的U和类中的T没任何关系

        public T GetDefault<U>()
        {
            return default(T);
        }

也可以在非泛型类中定义泛型方法，泛型方法可以和泛型类一样定义约束

    class MyDefault
    {
        public static T GetDefault<T>() where T:Animal
        {
            return default(T);
        }
    }

5.泛型委托

我们知道声明委托时，我们只要声明一个和方法签名、方法返回值一致的委托，就可以在程序中像声明对象一样使用这个委托，并把方法作为参数传递给委托变量，如下

    class Program
    {
        delegate int MyDelegate(int op1, int op2);
        static void Main(string[] args)
        {
            MyDelegate sum = new MyDelegate(Add);
            MyDelegate Multiply = new MyDelegate(Mul);

            Console.WriteLine(sum(, ));//
            Console.WriteLine(Multiply(, ));//
            Console.ReadLine();
        }

        public static int Add(int op1, int op2)
        {
            return op1 + op2;
        }

        public static int Mul(int op1, int op2)
        {
            return op1 * op2;
        }
    }

声明泛型委托只需要使用一个或几个泛型参数。泛型委托和一般委托相比，处理的数据类型更大了。

    class Program
    {
        delegate T MyGenericDelegate<T>(T op1, T op2);
        static void Main(string[] args)
        {
            MyGenericDelegate<int> sum2 = new MyGenericDelegate<int>(Add);
            MyGenericDelegate<int> Multiply2 = new MyGenericDelegate<int>(Mul);
            Console.WriteLine(sum(, ));//
            Console.WriteLine(Multiply(, ));//
            Console.ReadLine();
        }

        public static int Add(int op1, int op2)
        {
            return op1 + op2;
        }

        public static int Mul(int op1, int op2)
        {
            return op1 * op2;
        }
    }

 6.变体

协变和抗变(逆变)统称变体。

我们知道使用 多态性可以把子类的对象放在基类的变量中，比如

Cow myCow=new Cow("Cow");
Animal myAnimal =myCow;

那么对于泛型，像下面这样的代码能不能执行呢？

List<Cow> cows=new List<Cow>();
cows.Add(new Cow("Cow1"));
List<Animal> animals = cows;

答案是不能的，因为虽然Cow和Animal有继承关系, 但在泛型上类型List<Cow>和List<Animal>是两个不同的类型，它们不具有继承关系，不能互相转换。为了使上面的代码能运行，C#引入了另一个概念，协变。

在泛型中，在类型参数T前面使用out关键字就可以定义协变，协变只能在接口和泛型委托中使用，用作方法或者get块的返回值。C#中使用协变的一个常用接口是IEnumerable<T>

    // 摘要:
    //     公开枚举器，该枚举器支持在指定类型的集合上进行简单迭代。
    //
    // 类型参数:
    //   T:
    //     要枚举的对象的类型。
    [TypeDependency("System.SZArrayHelper")]
    public interface IEnumerable<out T> : IEnumerable
    {
        // 摘要:
        //     返回一个循环访问集合的枚举器。
        //
        // 返回结果:
        //     可用于循环访问集合的 System.Collections.Generic.IEnumerator<T>。
        IEnumerator<T> GetEnumerator();
    }

因为IEnumerable<T>定义了协变，所以以下代码是正确的。List<T>实现了IEnumerable<T>，利用多态性可以把List<Cow>对象存在IEnumerable<Cow>变量中，利用协变可以把IEnumerable<Cow>对象放在IEnumerable<Animal>变量中。

            List<Cow> cows = new List<Cow>();
            cows.Add(new Cow("Cow1"));
            IEnumerable<Cow> iCows = cows;//多态性
            IEnumerable<Animal> iAnimals = iCows;//协变

也可以在委托中定义协变

delegate T MyGenericDelegate2<out T>();

抗变：抗变和协变相反，抗变可以把泛型对象值存放在T类型的派生子类的泛型变量中。通过在类型变量T前面使用关键字in定义抗变，抗变只能用在接口和泛型委托中，用作方法参数。 比如IComparer<T>

    // 摘要:
    //     定义类型为比较两个对象而实现的方法。
    //
    // 类型参数:
    //   T:
    //     要比较的对象的类型。
    public interface IComparer<in T>
    {
        // 摘要:
        //     比较两个对象并返回一个值，指示一个对象是小于、等于还是大于另一个对象。
        //
        // 参数:
        //   x:
        //     要比较的第一个对象。
        //
        //   y:
        //     要比较的第二个对象。
        //
        // 返回结果:
        //     一个带符号整数，它指示 x 与 y 的相对值，如下表所示。值含义小于零x 小于 y。零x 等于 y。大于零x 大于 y。
        int Compare(T x, T y);
    }

上面的接口定义了抗变，所以我们可以排序Cows把IComparer<Cow> 对象传给 IComparer<Animal>类型的变量，从而实现排序

    class AnimalComparer : IComparer<Animal>
    {
        public static AnimalComparer Default = new AnimalComparer();

        public int Compare(Animal x, Animal y)
        {
            return x.Name.Length.CompareTo(y.Name.Length) ;
        }
    }

List<Cow> cows = new List<Cow>();
cows.Add(new Cow("Cow22"));
cows.Add(new Cow("Cow1"));
cows.Add(new Cow("Cow111"));
cows.Sort(AnimalComparer.Default);

7.习题

创建一个泛型类ShortCollection<T>,它实现了IList<T>接口，包含一个集合及集合的最大容量。这个最大容量可以通过构造函数设置，或者默认为10.构造函数还可以通过List<T>参数获取项的最初列表。该类与Collection<T>功能相同，但是如果试图添加超过最大容量的项，它会抛出IndexOutOfRangeException异常。

class ShortCollection<T>:IList<T>
    {
        protected int maxSize = ;
        protected Collection<T> innerCollection;

        public ShortCollection():this()
        { 

        }

        public ShortCollection(int size)
        {
            maxSize = size;
            innerCollection = new Collection<T>();
        }

        public ShortCollection(List<T> list):this(,list)
        {

        }

        public ShortCollection( int size,List<T> list)
        {
            maxSize =size ;
            if (list.Count < maxSize)
            {
                innerCollection = new Collection<T>(list);
            }
            else
            {
                ThrowTooManyItemException();
            }
        }

        protected void ThrowTooManyItemException()
        {
            throw new IndexOutOfRangeException("Unable to add any more items,maxinum size is " + maxSize + " items.");
        }
        public int IndexOf(T item)
        {
            return innerCollection.IndexOf(item);
        }

        public void Insert(int index, T item)
        {
            if (innerCollection.Count < maxSize)
                innerCollection.Insert(index, item);
            else
                ThrowTooManyItemException();
        }

        public void RemoveAt(int index)
        {
            innerCollection.RemoveAt(index);
        }

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

        public void Add(T item)
        {
            if (innerCollection.Count < maxSize)
                innerCollection.Add(item);
            else
                ThrowTooManyItemException();
        }

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

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

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

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

        public bool IsReadOnly
        {
            get { return (innerCollection as IList<T>).IsReadOnly; }
        }

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

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

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return innerCollection.GetEnumerator();
        }
    }