C#进阶学习第十一天

1.类型参数约束

一共5种约束

基类约束

1.给T指定的类型必须是某个类类型或该类的子类类型通过where给T添加约束
2.当指定基类约束后，T对象可以访问该基类中所有的共有的成员
3.只能指定一个基类

例：   public class vector<T> where T :person     
   {   public void show(){ array[1].print()}//调用person里面的print()方法,不能访问student里的成员
       public class person{…}
       public class student : person{…}

接口约束

1.给T指定的类型必须继承接口
2.T对象可以直接调用接口中的方法
3.可以指定多个接口

 例:     public interface myinter(){void show()}
         public class person :minter{public void show(){…}}
         public class vector<T>where T :minter
       { public void show(){ array[1].show()}     //调用接口中的show()方法

构造函数约束

1.约束给T指定的类型必须存在一个无参构造函数 where T : new()
2.new()约束可以和其它约束一起使用，但必须位于列表的最后面

 例:     public class  abc<T> where T :new()  
         { private T a; 
         public abc() { a = new T (); }
         } //不知道a是不是对象2.不知道有没有无参构造函数
         public class person {  private string name;  }
         abc<person> a = new abc<person> ();

引用类型

约束给T指定的类型为引用类型 where T : class

值类型约束

约束给T指定的类型为值类型 where T : struct

组合约束

1.同一类型形参可以使用多个约束，用逗号分隔开
2.不可以同时出现的约束：基类约束，值类型约束，引用类型约束 (重复了)
3.顺序：(基类约束，值类型约束，引用类型约束) 接口约束构造函数约束

2.泛型委托

例:    public delegate T mydele<T>(T  x, T  y);
       public static int add(int a,int b)  {return a + b; }
       public static double add(double a,double b)  { return a + b; }
       int main()
       {  mydele<int> a = add;  Console.WriteLine (a(1,2));
           mydele<double> b = add; Console.WriteLine (b(1.1,2.2));
       }

3.泛型接口

1.在继承接口时就要确定泛型参数
2.泛型接口中的泛型参数，可以直接用泛型类中的泛型参数

       public interface  Iadd<T> {  void add(T  x);  }
       public class pp :Iadd<int>  //在继承接口时就要确定泛型参数
      {private   int   [] array;
	   private int size;
	   public pp(int n){ array = new int[n]; size = 0;}
	   public void add(int x) {  array [size++] = x;   }
      }
       public class qq<T> :Iadd<T> //泛型接口中的泛型参数,可以直接用泛型类中的泛型参数
	  {private  T  [] array;
       private int size;
	   public qq(int n) { array = new T [n]; size = 0; }
	   public void add(T  x) { array [size++] = x; }
   	  }

4.泛型方法

     public class Node<T,V>
     {
     public T add(T a, V b)   public T add( V a ,T b)    public int add(int a, int b)
     {  return a;            { return b;                 {return a+b;
     }                       }                           }
    }

当Node <int,int> a = new Node<int,int>();
object x = a.add(2,11); //如果没有第三个add方法，将会报错，方法产生混淆，无法在第一和第二个选择