C# 泛型

泛型可以作用于类，结构和函数，之所以使用泛型，是为了用一种类，结构或函数，能处理不同的输入对象，而不用重复编写代码，从而提高代码的重用率

而输入的这个对象，就要T来泛指，也就是泛型。

泛型类与普通类的简单对比

泛型类的比一般类效率更高，因为没有装箱和拆箱操作

库中的泛型类

System.Collections; 空间中的 ArrayList 类；与 System.Collections.Generic; 空间中的 List<T>

普通类

var Alist = new ArrayList();

Alist.Add(1); // 向 List 增加 数据1，分配内存，装箱操作(将值类型（栈空间数据）变为引用类型（堆空间）)

Alist.Add("hello"); //ArrayList 类支持不同类型变量的添加

int i = (int) Alist[0]; // 从List 取得第0个数据，拆箱操作

String a = (String ) Alist[1]; //从这里可以看到有风险，如果1位置加入的不是 String 类型，那就会出错

泛型类

var Blist = new List<int>(); //初始化时限定只能加入 int类型

Blist.Add(1); //无装箱操作，为什么没有，不清楚哈哈

int i = Blist[0];//无拆箱操作

//对于不同的类型

var Blist = new List<String>;

Blist.Add("hehe"); //无装箱操作，为什么没有，不清楚哈哈

String a = Blist[0];//因为类型被限定 所以此处无风险了

 

创建泛型类

//创建泛型类
public  class C_A<T>{
    public  T  Value{get;  set};  //T 类型的属性

    public T Fuc(){
        T a = default; // 创建T类型时 怎么初始化，因为T类型未知用 0(初始化值类型)，用 null(初始化引用类型)，都不好，C#提供default 操作，避免这种尴尬，在运行时自动确定。
        ...
    }
}

对T的约束

where T : struct; // T 必须是值类型

where T : class; // T 必须是引用类型

where T : Inf; //必须实现接口

where T : Foo;  //必须派生自Foo

where T : new();//必须有构造函数，可以使用new方法

where  T1 : T2 //派生自泛型类型T2

public interface Inf_A{
   public void FuncA();
   public void FuncB();
}


public  class C_A<T>
 where T : Inf_A, new()  //必须实现接口a 并且必须有默认构造函数
{
    private T value;
    public C_A(T value) {  //构造函数
        this.value = value;
    }

    public void FuncA(){  //实现接口a 函数
    
    }

    public void FuncB(){ //实现接口a 函数

    }
}

泛型的继承

泛型继承泛型

public class Base<T>{
    
}

public class Class_A<T> : Base<T>{

}

泛型继承泛型类的具体类实现

public class Base<T>{
    
}

public class Class_A<T> : Base<int>{  //Base 里面放了特点类

}

普通类继承泛型类的具体类实现

public class Base<T>{
    
}

public class Class_B : Base<int>{  //Base 里面放了特点类

}

泛型的静态成员

public class Base<T>{
    public static int a;   //a 是泛型类的静态成员    
}


var m = Base<int>; //创建一个静态成员a，输入泛型类的int实现
var n = Base<string>; //再创建一个静态成员a，属于泛型类的string 实现
var o = Base<int>;  //不再创建静态成员，因为 m 已经创建过输入 int 泛型实现的 静态成员

泛型应用在接口

接口定义方法和属性，但不实现

类继承泛型接口并实现其方法

public interface Inf_A<T>{
   void func(T a); //定义方法 注意：接口没有访问修饰符
   int A{get;set}; //定义属性
}

public class Class_A : Base<T>{ 

  public  void func(T a) //实现方法
  {

  }

  public  int A{get;set}; //实现属性
}

接口的协变与抗变(in/out)

//首先定义一个泛型接口
public interface Inf_A<T>{
}

//然后定义一个父类
public class Class_Base{

}

//然后定义一个子类继承父类
public class Class_extern : Class_Base{

}

//然后定义一个类继承自这个接口
public class Class_Handel: Inf_A<>{ 

}

//创建一个父类的接口实例
Inf_A<Class_Base>  A = new Class_Handel(); //因为Class_Handel类继承自接口，所以可以被接口引用
//创建一个子类的接口实现; 并父类的接口实现付给子类
Inf_A<Class_extern>  B = A; //也就是说此时 B 作为扩展类被父类萎缩赋值,这时编译器不支持
//当把接口定义改为 public interface Inf_A<in T>时，编译器就不报错了，这就叫抗变，也叫逆变

反过来
//创建一个子类的接口实例
Inf_A<Class_extern>  A = new Class_Handel();
//创建一个父类的接口实现; 将子类的接口实现付给父类
Inf_A<Class_Base>  B = A; //也就是说此时 B 作为父类被子类赋值属于扩充赋值,这时编译器也不支持
//当把接口定义改为 public interface Inf_A<out T>时，编译器不报错了，这就叫协变