泛型，泛型约束

什么是泛型？

泛型（Generics） 是一种编程技能，广泛应用于面向对象编程（OOP）中，特殊是在C#、Java等现代编程语言中。泛型的核心思想是创建可以在多种数据范例上工作的类、接口和方法，而不需要为每种数据范例单独编写代码。这不但进步了代码的重用性，还增强了范例安全性，减少了运行时错误。
泛型的主要优点

• 范例安全性：
  
  
  
  • 泛型在编译时举行范例检查，确保范例的一致性，减少运行时范例转换错误。
    
  
  
• 代码重用：
  
  
  
  • 通过泛型，可以编写适用于多种数据范例的通用代码，而不需要为每种数据范例编写单独的实现。
    
  
  
• 性能提升：
  
  
  
  • 泛型避免了装箱（boxing）和拆箱（unboxing）操作，进步了性能，特殊是在处理值范例时。
    
  
  
• 可读性和可维护性：
  
  
  
  • 泛型代码更易于阅读和维护，因为范例信息在编译时就已经明确。
    
  
  

泛型的实现
<ol>泛型类：
定义一个类，使其可以处理多种数据范例的实例。

1. public class Box<T>
2. {
3.         private T _content;
5.         public void SetContent(T content)
6.         {
7.                 _content = content;
8.         }
10.         public T GetContent()
11.         {
12.                 return _content;
13.         }
14. }
16. public class Program
17. {
18.         public static void Main()
19.         {
20.                 Box<int> intBox = new Box<int>();
21.                 intBox.SetContent(42);
22.                 Console.WriteLine(intBox.GetContent()); // 输出: 42
24.                 Box<string> stringBox = new Box<string>();
25.                 stringBox.SetContent("Hello, World!");
26.                 Console.WriteLine(stringBox.GetContent()); // 输出: Hello, World!
27.         }
28. }

复制代码

泛型接口：
定义一个接口，使其可以处理多种数据范例的实例。

1. public interface IStorage<T>
2. {
3.         void Store(T item);
4.         T Retrieve();
5. }
7. public class Storage<T> : IStorage<T>
8. {
9.         private T _item;
11.         public void Store(T item)
12.         {
13.                 _item = item;
14.         }
16.         public T Retrieve()
17.         {
18.                 return _item;
19.         }
20. }
22. public class Program
23. {
24.         public static void Main()
25.         {
26.                 IStorage<int> intStorage = new Storage<int>();
27.                 intStorage.Store(100);
28.                 Console.WriteLine(intStorage.Retrieve()); // 输出: 100
30.                 IStorage<string> stringStorage = new Storage<string>();
31.                 stringStorage.Store("Generic Storage");
32.                 Console.WriteLine(stringStorage.Retrieve()); // 输出: Generic Storage
33.         }
34. }

复制代码

泛型方法：
定义一个方法，使其可以处理多种数据范例的参数和返回值。

1. public class GenericMethods
2. {
3.         public static T GetDefault<T>() where T : new()
4.         {
5.                 return new T();
6.         }
8.         public static void Print<T>(T item)
9.         {
10.                 Console.WriteLine(item);
11.         }
12. }
14. public class Program
15. {
16.         public static void Main()
17.         {
18.                 int defaultInt = GenericMethods.GetDefault<int>();
19.                 Console.WriteLine(defaultInt); // 输出: 0
21.                 string defaultString = GenericMethods.GetDefault<string>();
22.                 Console.WriteLine(defaultString); // 输出: (空字符串)
24.                 GenericMethods.Print(42); // 输出: 42
25.                 GenericMethods.Print("Hello, World!"); // 输出: Hello, World!
26.         }
27. }

复制代码

泛型约束：
可以为泛型类、接口和方法添加约束，以限制泛型参数的范例。
常见的约束包括：

• where T : new()：要求泛型参数必须有一个无参构造函数。
  
• where T : class：要求泛型参数必须是引用范例。
  
• where T : struct：要求泛型参数必须是值范例。
  
• where T : IInterface：要求泛型参数必须实现特定的接口。
  
• where T : BaseClass：要求泛型参数必须继续自特定的基类。
  1.   public class GenericConstraint<T> where T : new()
  2.   {
  3.           public T CreateInstance()
  4.           {
  5.                   return new T();
  6.           }
  7.   }
  9.   public class MyClass
  10.   {
  11.           public void MyMethod()
  12.           {
  13.                   Console.WriteLine("MyClass instance created.");
  14.           }
  15.   }
  17.   public class Program
  18.   {
  19.           public static void Main()
  20.           {
  21.                   GenericConstraint<MyClass> constraint = new GenericConstraint<MyClass>();
  22.                   MyClass instance = constraint.CreateInstance();
  23.                   instance.MyMethod(); // 输出: MyClass instance created.
  24.           }
  25.   }

  复制代码

泛型的应用场景
1.集合类：
泛型集合类（如List