image.png

泛型

  • 为什么需要泛型：避免成员膨胀或类型膨胀
  • 正交性：泛型类型（类、接口、委托……） 泛型成员（属性、方法、字段……）
  • 类型方法的参数推断
  • 泛型与委托，Lambda 表达式

泛型在面向对象中的地位与接口相当。其内容很多，今天只介绍最常用最重要的部分。

基本介绍

（22）泛型，partial类，枚举，结构体 - 图3
正交性：泛型和其它的编程实体都有正交点，导致泛型对编程的影响广泛而深刻。
泛化 <-> 具体化

泛型类示例

示例背景：开了个小商店，一开始只卖苹果，卖的苹果用小盒子装上给顾客。顾客买到后可以打开盒子看苹果颜色。

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         var apple = new Apple { Color = "Red" };
  6.         var box = new Box { Cargo = apple };
  7.         Console.WriteLine(box.Cargo.Color);
  8.     }
  9. }
  10. class Apple
  11. {
  12.     public string Color { get; set; }
  13. }
  14. class Box
  15. {
  16.     public Apple Cargo { get; set; }
  17. }

后来小商店要增加商品（卖书），有下面几种处理方法。
一：我们专门为 Book 类添加一个 BookBox 类的盒子。

  1. static void Main(string[] args)
  2. {
  3.       var apple = new Apple { Color = "Red" };
  4.       var box = new AppleBox { Cargo = apple };
  5.       Console.WriteLine(box.Cargo.Color);
  7.     var book = new Book { Name = "New Book" };
  8.       var bookBox = new BookBox { Cargo = book };
  9.       Console.WriteLine(bookBox.Cargo.Name);
  10. }

image.pngimage.png*
现在代码就出现了“类型膨胀”的问题。未来随着商品种类的增多，盒子种类也须越来越多，类型膨胀，不好维护。
二：用同一个 Box 类，每增加一个商品时就给 Box 类添加一个属性。

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         var apple = new Apple { Color = "Red" };
  6.         var book = new Book { Name = "New Book" };
  7.         var box1 = new Box { Apple = apple };
  8.         var box2 = new Box { Book = book };
  9.     }
  10. }
  11. ...
  12. class Book
  13. {
  14.     public string Name { get; set; }
  15. }
  17. class Box
  18. {
  19.     public Apple Apple { get; set; }
  20.     public Book Book { get; set; }
  21. }

这会导致每个 box 变量只有一个属性被使用，也就是“成员膨胀”（类中的很多成员都是用不到的）。
三：Box 类里面的 Cargo 改为 Object 类型。

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         var apple = new Apple { Color = "Red" };
  6.         var book = new Book { Name = "New Book" };
  7.         var box1 = new Box { Cargo = apple };
  8.         var box2 = new Box { Cargo = book };
  9.         Console.WriteLine((box1.Cargo as Apple)?.Color);
  10.     }
  11. }
  12. ...
  13. class Box
  14. {
  15.     public Object Cargo{ get; set; }
  16. }

使用时必须进行强制类型转换或 as，即向盒子里面装东西省事了，但取东西时很麻烦。
四：泛型登场。

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         var apple = new Apple { Color = "Red" };
  6.         var book = new Book { Name = "New Book" };
  7.         var box1 = new Box<Apple> { Cargo = apple };
  8.         var box2 = new Box<Book> { Cargo = book };
  10.         Console.WriteLine(box1.Cargo.Color);
  11.         Console.WriteLine(box2.Cargo.Name);
  12.     }
  13. }
  14. ...
  15. class Box<TCargo> //此处TCargo为类型参数
  16. {
  17.     public TCargo Cargo { get; set; }
  18. }

泛型类特化后，都是强类型：
image.png

泛型接口示例

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         //var stu = new Student<int>();
  6.         //stu.Id = 101;
  7.         //stu.Name = "Timothy";
  9.         var stu = new Student<ulong>();
  10.         stu.Id = 1000000000000001;
  11.         stu.Name = "Timothy";
  13.         var stu2 = new Student();
  14.         stu2.Id = 100000000001;
  15.         stu2.Name = "Elizabeth";
  16.     }
  17. }
  19. interface IUnique<T>
  20. {
  21.     T Id { get; set; }
  22. }
  24. // 泛型类实现泛型接口
  25. class Student<T> : IUnique<T>
  26. {
  27.     public T Id { get; set; }
  28.     public string Name { get; set; }
  29. }
  31. // 具体类实现特化化后的泛型接口
  32. class Student : IUnique<ulong>
  33. {
  34.     public ulong Id { get; set; }
  35.     public string Name { get; set; }
  36. }

泛型集合

.NET Framework 中常用的数据结构基本都是泛型的。
编程中处理的数据很多都存储在如数组、列表、字典、链表等集合中，这些集合都是泛型的，它们的基接口和基类都是泛型的。

这些泛型集合都集中在 System.Collections.Generic 命名空间中。

  1. static void Main(string[] args)
  2. {
  3.     IList<int> list = new List<int>();
  4.     for (var i = 0; i < 100; i++)
  5.     {
  6.         list.Add(i);
  7.     }
  9.     foreach (var item in list)
  10.     {
  11.         Console.WriteLine(item);
  12.     }
  13. }

List 的定义：

  1. public class List<T> : ICollection<T>, IEnumerable<T>, IEnumerable, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection, IList
  2. {
  3.   ...
  4. }
  • IEnumerable：可迭代
  • ICollection：集合，可以添加和移除元素

注：很多泛型类型带有不止一个类型参数，例如 IDictionary。

  1. IDictionary<int, string> dict = new Dictionary<int, string>();
  2. dict[1] = "Timothy";
  3. dict[2] = "Michael";
  4. Console.WriteLine($"Student #1 is {dict[1]}");
  5. Console.WriteLine($"Student #2 is {dict[2]}");

泛型算法示例

泛型不仅与面向对象和数据结构有关系，它也和算法密不可分。

Zip 方法：像拉拉链一样合并整型数组。

  1. static void Main(string[] args)
  2. {
  3.     int[] a1 = { 1, 2, 3, 4, 5 };
  4.     int[] a2 = { 1, 2, 3, 4, 5, 6 };
  5.     double[] a3 = { 1.1, 2.2, 3.3, 4.4, 5.5 };
  6.     double[] a4 = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 };
  7.     var result = Zip(a1, a2);
  8.     Console.WriteLine(string.Join(",", result));
  9. }
  11. static int[] Zip(int[] a, int[] b)
  12. {
  13.     int[] zipped = new int[a.Length + b.Length];
  14.     int ai = 0, bi = 0, zi = 0;
  15.     do
  16.     {
  17.         if (ai < a.Length) zipped[zi++] = a[ai++];
  18.         if (bi < b.Length) zipped[zi++] = b[bi++];
  19.     } while (ai < a.Length || bi < b.Length);
  21.     return zipped;
  22. }

现在的问题是：当前的 Zip 仅对 int 类型数组有效，无法合并两个 double 数组。

使用泛型后：

  1. static void Main(string[] args)
  2. {
  3.     int[] a1 = { 1, 2, 3, 4, 5 };
  4.     int[] a2 = { 1, 2, 3, 4, 5, 6 };
  5.     var result = Zip(a3, a4);
  6.     Console.WriteLine(string.Join(",", result));
  8.     double[] a3 = { 1.1, 2.2, 3.3, 4.4, 5.5 };
  9.     double[] a4 = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 };
  10.     var result2 = Zip(a3, a4);
  11.     Console.WriteLine(string.Join(",", result2));
  12. }
  14. static T[] Zip<T>(T[] a, T[] b)
  15. {
  16.     T[] zipped = new T[a.Length + b.Length];
  17.     int ai = 0, bi = 0, zi = 0;
  18.     do
  19.     {
  20.         if (ai < a.Length) zipped[zi++] = a[ai++];
  21.         if (bi < b.Length) zipped[zi++] = b[bi++];
  22.     } while (ai < a.Length || bi < b.Length);
  24.     return zipped;
  25. }

泛型委托

● C# 内置了很多泛型委托，它们经常会和 Lambda 表达式配合使用，构成 LINQ 查询。
Action 泛型委托：

  1. static void Main(string[] args)
  2. {
  3.     Action<string> a1 = Say;
  4.     a1("Timothy"); //输出 "Hello, Timothy!"
  6.     Action<int> a2 = Mul;
  7.     a2(1); //输出100
  8. }
  10. static void Say(string str)
  11. {
  12.     Console.WriteLine($"Hello, {str}!");
  13. }
  15. static void Mul(int x)
  16. {
  17.     Console.WriteLine(x * 100);
  18. }

Func 泛型委托：

  1. static void Main(string[] args)
  2. {
  3.     Func<int, int, int> f1 = Add;
  4.     Console.WriteLine(f1(1, 2));
  6.     Func<double, double, double> f2 = Add;
  7.     Console.WriteLine(f2(1.1, 2.2));
  8. }
  10. static int Add(int a, int b)
  11. {
  12.     return a + b;
  13. }
  15. static double Add(double a, double b)
  16. {
  17.     return a + b;
  18. }

配合 Lambda 表达式：

  1. //Func<int, int, int> f1 = (int a, int b) => { return a + b; };
  2. Func<int, int, int> f1 = (a, b) => { return a + b; };
  3. Console.WriteLine(f1(1, 2));

partial 类

下面依次讲解 partial 类的三大用途。

减少派生类

学习类的继承时就提到过一个概念，“把不变的内容写在基类里，在子类里写经常改变的内容”。这就导致一个类中只要有经常改变的内容，我们就要为它声明一个派生类，如果改变的部分比较多，还得声明多个或多层派生类，导致派生结构非常复杂。
有 partial 类后，我们按照逻辑将类切分成几块，每块作为一个逻辑单元单独更新迭代，这些分块合并起来还是一个类。

partial 类与 EF

使用 EF 时，EF 会自动创建映射 Book 的实体类。如果你在自动生成的 Book 实体类中声明方法，一会刷新 EF 实体时，你手写的代码将会被覆盖。
同时我们注意到 EF 创建的 Book 实体类是 partial 类，于是我们可以在别的位置声明 partial 类，添加方法。
○其中一部分代码：（必须保证名称空间一致）
image.pngimage.png
○另一部分代码：（必须保证名称空间一致）

  1. public partial class Book
  2. {
  3.     public string Report()
  4.     {
  5.         return $"#{ID} Name:{Name} Price:{Price}";
  6.     }
  7. }

详细调用 Report()：

  1. static void Main(string[] args)
  2. {
  3.     var dbContext = new BookstoreEntities();
  4.     var books = dbContext.Books;
  5.     foreach (var book in books)
  6.     {
  7.         Console.WriteLine(book.Report());
  8.     }
  9. }

partial 类与 WinForm、WPF、ASP.NET Core

partial 类还允许一个类的不同部分，使用不同的编程语言来编写。

（1）WinForm 的 Designer(设计) 部分和后台逻辑代码部分都是用 C# 编写的：
（22）泛型，partial类，枚举，结构体 - 图9
（22）泛型，partial类，枚举，结构体 - 图10
（2）WPF 的界面使用 XAML（最终会被编译成 C#），后台依然是 C#：
（22）泛型，partial类，枚举，结构体 - 图11
（22）泛型，partial类，枚举，结构体 - 图12
（3）新建 ASP.NET Core MVC 项目，找到 Views\Home\Index.cshtml。
cshtml 最终一部分也将被编译为 C# 代码。

cs→C#；html→超文本标记语言缩写；cshtml→看上去像是html，最终也会被编译成c#代码。

枚举类型

image.png

  • 人为限定取值范围的整数
  • 整数值的对应
  • 比特位式用法

    枚举示例

    如何设计员工类的级别属性。
  1. 使用数字？ 大小不明确
  2. 使用字符串？ 无法约束程序员的输入

使用枚举，即限定输入，又清晰明了：

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         var employee = new Person
  6.         {
  7.             Level = Level.Employee
  8.         };
  10.         var boss = new Person
  11.         {
  12.             Level = Level.Boss
  13.         };
  15.         Console.WriteLine(boss.Level > employee.Level);// True
  17.         Console.WriteLine((int)Level.Employee);// 0
  18.         Console.WriteLine((int)Level.Manager); // 100
  19.         Console.WriteLine((int)Level.Boss);    // 200
  20.         Console.WriteLine((int)Level.BigBoss); // 201
  21.     }
  22. }
  24. enum Level 
  25. {
  26.     Employee,
  27.     Manager = 100,
  28.     Boss = 200,
  29.     BigBoss,
  30. }
  32. class Person
  33. {
  34.     public int Id { get; set; }
  35.     public string Name { get; set; }
  36.     public Level Level { get; set; }
  37. }

●一般情况下（没有给定具体值的情况下），按照0,1,2,3…的顺序从小到大排列。 ●给定具体值，则按照值的顺序（基于上一个值+1 或 给定值）排列下去…

代码快捷键：Alt + 左键：竖向选择…

枚举的比特位用法

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         var employee = new Person
  6.         {
  7.             Name = "Timothy",
  8.             Skill = Skill.Drive | Skill.Cook | Skill.Program | Skill.Teach
  9.             //按位取或
  10.         };
  12.         Console.WriteLine(employee.Skill); // 15
  14.         // 过时用法不推荐
  15.         //Console.WriteLine((employee.Skill & Skill.Cook) == Skill.Cook); // True
  17.         // .NET Framework 4.0 后推荐的用法
  18.         Console.WriteLine((employee.Skill.HasFlag(Skill.Cook))); // True
  19.     }
  20. }
  22. [Flags]
  23. enum Skill
  24. {
  25.     Drive = 1,//二级制0001
  26.     Cook = 2,//二级制0010
  27.     Program = 4,//二级制0100
  28.     Teach = 8,//二级制1000
  29. }
  31. class Person
  32. {
  33.     public int Id { get; set; }
  34.     public string Name { get; set; }
  35.     public Skill Skill { get; set; }
  36. }
  1. 比特位（Flag）用法需给枚举标注 Flags 特性
  2. 比特位用法的更多内容参考官方文档 Non-exclusive members and the Flags attribute
  3. 枚举默认父类是 int，你也可以显式指定它的父类

    结构体

    image.png
  • 值类型，可装/拆箱
  • 可实现接口，不能派生自类/结构体
  • 不能有显式无参构造器

    结构体示例

    结构体是值类型：

    值类型：与值类型相关联的内存存储的就是值类型的实例…

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         var stu = new Student { Id = 101, Name = "Timothy" };
  7.         // 装箱：复制一份栈上的 stu ，放到堆上去，然后用 obj 引用堆上的 student 实例
  8.         object obj = stu;
  10.         // 拆箱
  11.         Student stu2 = (Student)obj;
  12.         Console.WriteLine($"#{stu2.Id} Name:{stu2.Name}");
  13.     }
  14. }
  16. struct Student
  17. {
  18.     public int Id { get; set; }
  19.     public string Name { get; set; }
  20. }

因为是值类型，所以拷贝时是值复制：

  1. static void Main(string[] args)
  2. {
  3.     var stu1 = new Student { Id = 101, Name = "Timothy" };
  5.     // 结构体赋值是值复制
  6.     var stu2 = stu1;
  7.     stu2.Id = 1001;
  8.     stu2.Name = "Michael";
  10.     Console.WriteLine($"#{stu1.Id} Name:{stu1.Name}");
  11.     // #101 Name:Timothy
  12. }

结构体可以实现接口

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         var stu1 = new Student { Id = 101, Name = "Timothy" };
  6.         stu1.Speak();
  7.     }
  8. }
  10. interface ISpeak
  11. {
  12.     void Speak();
  13. }
  15. struct Student : ISpeak
  16. {
  17.     public int Id { get; set; }
  18.     public string Name { get; set; }
  20.     public void Speak()
  21.     {
  22.         Console.WriteLine($"I'm #{Id} student {Name}");
  23.     }
  24. }

注：

  1. 将结构体转换为接口时要装箱
  2. 结构体不能有基类或基结构体，只可以实现接口

    结构体不能有显式无参构造器

    image.png
    因为结构体是值类型，它有默认的无参构造器，该构造器中将字段初始化为 0 或 NULL。

    感谢 Tim 老师五年的付出
    image.png

    （22）泛型，partial类，枚举，结构体 - 图17
    （22）泛型，partial类，枚举，结构体 - 图18