【Unity|C#】基础篇(10)——泛型（Generic）/ 泛型约束条件（where）

【学习资料】

　　《C#图解教程》（第17章）：https://www.cnblogs.com/moonache/p/7687551.html
　　电子书下载：https://pan.baidu.com/s/1mhOmBG0

 

【内容】 

• • 定义
  • 泛型类（class）
  • 泛型函数
  • 泛型委托
  • 多个泛型定义（T1、T2、T3）
  • 泛型的约束条件（where）

 

---

【笔记】

• 定义
  • 与C++中的模板template<T>一样
  • 可使用泛型的类型：类、结构、接口、委托、方法
  • 注：泛型不只有一个T，可以定义多个泛型T1、T2、T3 ...

 

•  泛型类（class）
  • 未知类型T，在创建对象时确定，这样可以避免重载多个MyList

  • // T的类型在创建对象时确定
    public class MyList<T>
    {
        private int size = 10;
        public T[] values;
        public MyList()
        {
            values = new T[size];
        }
    }
    
    void Start()
    {
        MyList<int> myList_int = new MyList<int>();          // T 为 int
        MyList<string> myList_string = new MyList<string>(); // T 为 string
        myList_int.values[0] = 1;
        myList_string.values[0] = "Alice";
    }

• 泛型函数
  • 减少函数重载，一个泛型T适配所有不同类型的参数

  • // 交换a和b
    public void SwapValue<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }
    
    void Start()
    {
        int i1 = 1, i2 = 2;
        string s1 = "Alice", s2 = "Bob";
    
        SwapValue(ref i1, ref i2); // T 为 int
        SwapValue(ref s1, ref s2); // T 为 string
        Debug.Log(i1); // 输出：2
        Debug.Log(s1); // 输出：Bob
    }

• 泛型委托
  • 与泛型类定义类似

  • // 泛型委托
    delegate T NumberChanger<T>(T a, T b);
    
    public int AddNum(int a, int b)
    {
        return a + b;
    }
    public string AddString(string a, string b)
    {
        return a + b;
    }
    
    void Start()
    {
        // T 为 int
        NumberChanger<int> numberChanger_int = new NumberChanger<int>(AddNum);
        // T 为 string
        NumberChanger<string> numberChanger_string = new NumberChanger<string>(AddString);
    } 

 

• 多泛型T定义
  • 泛型不一定只有一个T，也可以定义多个，T1、T2、T3 ...

  • // 多泛型T委托
    delegate T3 NumberChanger<T1, T2, T3>(T1 a, T2 b);
    
    // int 与 float 相加，返回string
    public string AddNumToString(int a, float b)
    {
        return (a + b).ToString();
    }
    
    void Start()
    {
        // 创建泛型变量
        NumberChanger<int, float, string> numberChanger = new NumberChanger<int, float, string>(AddNumToString);
    }

 

• 泛型的约束条件（where）
  • 对泛型T进行类型约束，在定义为泛型的代码后面加  where T: xxx ，表示T必须为xxx类型

• • 举例：

  • public class Major // 职业
    {
    
    };
    public class Teacher : Major // 教师
    {
    
    }
    
    public class Person<T1, T2, T3> 
        where T1 : class    // T1 必须是个类 类型
        where T2 : struct   // T2 必须是个结构 类型
        where T3 : Major    // T3 必须是基类为Major的类 
    {
        T1 value1;
        T2 value2;
        T3 value3;
    }
    
    void Start()
    {
        // 报错：T1和T3不满足约束条件
        //Person<int, int, int> person1 = new Person<int, int, int>();
    
        // 正确：
        //  string  类型为 class System.String
        //  int     类型为 struct System.Int32
        //  Teacher 类型为 class Major
        Person<string, int, Teacher> person2 = new Person<string, int, Teacher>(); 
    }