C# 技术使用笔记：泛型的使用方法
1. 泛型基础
1.1 泛型的定义与作用
泛型是 C# 语言中一个非常强大且常用的特性，它允许在编写代码时使用类型参数来创建类、方法或接口，而不需要在编写代码时指定具体的类型。类型参数可以是任何类型，直到代码实际执行时，类型才会被确定。例如，常见的泛型类 List，其中 T 就是类型参数，可以是 int、string、自定义类 Person 等。
使用泛型的主要好处包括：
-
类型安全：编译器会确保类型安全，避免了运行时的类型转换错误。例如，使用
List时，只能添加int类型的元素，编译器会阻止其他类型的数据进入。 -
提高代码复用性：泛型代码可以用于不同的类型，而不需要为每个类型重复编写逻辑。比如一个泛型方法
Print可以处理任意类型的参数，无论是(T value) int还是string，都无需重新编写方法。 -
性能优化：尤其在处理值类型时，泛型能够提高性能。以
List为例，与使用非泛型的ArrayList相比，泛型列表避免了装箱和拆箱操作，从而提升了性能。
1.2 泛型与非泛型的对比
为了更直观地理解泛型的优势，我们可以通过一个简单的例子来对比泛型和非泛型的实现方式。
非泛型实现
假设我们需要一个方法来交换两个变量的值，如果不使用泛型，我们可能需要为每种类型都写一个方法：
public static void SwapInt(ref int a, ref int b)
{
int temp = a;
a = b;
b = temp;
}
public static void SwapString(ref string a, ref string b)
{
string temp = a;
a = b;
b = temp;
}这种方法的缺点是代码冗余，每种类型都需要单独实现一个方法，而且如果要支持更多类型，就需要继续扩展代码。
泛型实现
使用泛型后，我们可以用一个方法来处理所有类型：
public static void Swap(ref T a, ref T b)
{
T temp = a;
a = b;
b = temp;
} 调用时，编译器会根据传入参数的类型自动推断类型 T：
int a = 10, b = 20;
Swap(ref a, ref b); // 编译器推断 T 为 int
string c = "Hello", d = "World";
Swap(ref c, ref d); // 编译器推断 T 为 string通过泛型，我们不仅减少了代码量，还提高了代码的可维护性和扩展性。
2. 泛型类的使用
2.1 定义泛型类
在 C# 中，泛型类是一种强大的工具，它允许我们创建可以处理不同类型数据的类，同时保持类型安全和代码复用性。定义泛型类的基本语法如下：
public class GenericClass
{
private T _data;
public GenericClass(T data)
{
_data = data;
}
public T GetData()
{
return _data;
}
public void SetData(T data)
{
_data = data;
}
} 在这个例子中，GenericClass 是一个泛型类，T 是类型参数。这个类有一个私有字段 _data，它的类型是 T，这意味着 _data 的类型在实例化类时才会确定。类中还提供了构造函数、GetData 方法和 SetData 方法，这些方法都使用了类型参数 T，从而保证了类型安全。
定义泛型类时，可以为类型参数添加约束，以限制可以使用的类型。例如，如果希望类型参数必须是引用类型，可以使用 class 约束：
public class GenericClass where T : class
{
// 类的实现
} 如果希望类型参数必须是值类型，可以使用 struct 约束：
public class GenericClass where T : struct
{
// 类的实现
} 还可以为类型参数添加其他约束，如指定必须实现某个接口或继承某个基类：
public class GenericClass where T : IComparable
{
// 类的实现
} 通过添加约束，可以确保泛型类在使用时符合特定的类型要求，从而提高代码的灵活性和安全性。
2.2 实例化泛型类
实例化泛型类时，需要指定类型参数的实际类型。例如，使用前面定义的 GenericClass，可以这样实例化：
GenericClass intClass = new GenericClass(10);
GenericClass stringClass = new GenericClass("Hello"); 在第一个例子中，T 被指定为 int，因此 intClass 是一个处理 int 类型数据的泛型类实例。在第二个例子中，T 被指定为 string，因此 stringClass 是一个处理 string 类型数据的泛型类实例。
实例化泛型类后，可以像操作普通类一样操作它。例如，可以调用 GetData 和 SetData 方法：
int data = intClass.GetData(); // 获取 int 类型的数据
intClass.SetData(20); // 设置 int 类型的数据
string str = stringClass.GetData(); // 获取 string 类型的数据
stringClass.SetData("World"); // 设置 string 类型的数据通过泛型类的实例化和使用，我们可以编写出更加灵活、通用且类型安全的代码，从而提高代码的复用性和可维护性。
3. 泛型方法的使用
3.1 定义泛型方法
泛型方法是泛型编程中的重要组成部分，它允许我们在方法级别上使用类型参数，从而实现更灵活的代码复用。定义泛型方法的基本语法如下：
public static T Add(T a, T b)
{
return (dynamic)a + (dynamic)b;
} 在这个例子中，Add 是一个泛型方法，T 是类型参数。该方法接受两个参数 a 和 b，它们的类型都是 T，并返回它们的和。通过使用 dynamic 关键字，我们可以实现对不同类型的操作，但需要注意性能和类型安全问题。
定义泛型方法时，类型参数可以出现在方法的返回值、参数列表或局部变量中。例如：
public static T GetMax(T a, T b) where T : IComparable
{
return a.CompareTo(b) > 0 ? a : b;
} 在这个例子中，GetMax 方法通过 IComparable 接口的 CompareTo 方法比较两个参数的大小，并返回较大的值。通过添加 where T : IComparable 约束，我们确保了类型参数 T 必须实现 IComparable 接口，从而保证了代码的类型安全。
3.2 调用泛型方法
调用泛型方法时，可以显式指定类型参数，也可以让编译器根据上下文自动推断类型参数。例如：
int result1 = Add(1, 2); // 显式指定类型参数
string result2 = Add("Hello", "World"); // 显式指定类型参数 在上述代码中，我们显式指定了类型参数 int 和 string，分别调用了 Add 和 Add 方法。
编译器也可以根据方法的参数类型自动推断类型参数：
int a = 1, b = 2;
int result3 = Add(a, b); // 编译器推断 T 为 int
string c = "Hello", d = "World";
string result4 = Add(c, d); // 编译器推断 T 为 string在上述代码中，编译器根据变量 a 和 b 的类型推断出 T 为 int，根据变量 c 和 d 的类型推断出 T 为 string。
泛型方法的调用不仅减少了代码量，还提高了代码的可读性和可维护性。通过合理使用泛型方法，我们可以编写出更加通用和灵活的代码，从而提高开发效率。
4. 泛型接口的使用
4.1 定义泛型接口
泛型接口是 C# 中一种强大的特性，它允许在接口中使用类型参数来定义通用的方法、属性或索引器。通过泛型接口，可以创建能够处理不同类型数据的接口，同时保持类型安全和代码复用性。定义泛型接口的基本语法如下：
口的基本语法如下：
public interface IGenericInterface
{
T GetData();
void SetData(T data);
} 在这个例子中，IGenericInterface 是一个泛型接口，T 是类型参数。接口中定义了两个方法：GetData 和 SetData，它们的返回值和参数类型都是 T。
定义泛型接口时，可以为类型参数添加约束，以限制可以使用的类型。例如，如果希望类型参数必须是引用类型，可以使用 class 约束：
public interface IGenericInterface where T : class
{
T GetData();
void SetData(T data);
} 如果希望类型参数必须是值类型，可以使用 struct 约束：
public interface IGenericInterface where T : struct
{
T GetData();
void SetData(T data);
} 还可以为类型参数添加其他约束，如指定必须实现某个接口或继承某个基类：
public interface IGenericInterface where T : IComparable
{
T GetData();
void SetData(T data);
} 通过添加约束，可以确保泛型接口在实现时符合特定的类型要求，从而提高代码的灵活性和安全性。
4.2 实现泛型接口
实现泛型接口时，需要指定类型参数的实际类型。例如，使用前面定义的 IGenericInterface，可以这样实现：
public class GenericClass : IGenericInterface
{
private int _data;
public GenericClass(int data)
{
_data = data;
}
public int GetData()
{
return _data;
}
public void SetData(int data)
{
_data = data;
}
} 在这个例子中，GenericClass 实现了 IGenericInterface，将类型参数 T 指定为 int。因此，GetData 和 SetData 方法的返回值和参数类型都是 int。
实现泛型接口时，也可以使用泛型类来实现。例如：
public class GenericClass : IGenericInterface
{
private T _data;
public GenericClass(T data)
{
_data = data;
}
public T GetData()
{
return _data;
}
public void SetData(T data)
{
_data = data;
}
} 在这个例子中，GenericClass 是一个泛型类，它实现了泛型接口 IGenericInterface。这样，GenericClass 可以处理任意类型的 T，并保持类型安全。
实现泛型接口时，还可以通过显式接口实现来隐藏接口中的某些成员。例如：
public class GenericClass : IGenericInterface
{
private int _data;
public GenericClass(int data)
{
_data = data;
}
int IGenericInterface.GetData()
{
return _data;
}
void IGenericInterface.SetData(int data)
{
_data = data;
}
} 在这个例子中，GenericClass 显式实现了 IGenericInterface 中的 GetData 和 SetData 方法。这些方法只能通过接口类型访问，而不能通过类类型访问，从而隐藏了接口中的某些成员。
通过实现泛型接口，可以创建更加灵活、通用且类型安全的代码，从而提高代码的复用性和可维护性。
5. 泛型委托的使用
5.1 定义泛型委托
泛型委托是 C# 中一种非常灵活的特性，它允许我们定义可以处理不同类型参数和返回值的委托。通过泛型委托，我们可以编写更加通用和灵活的代码，从而提高代码的复用性和可维护性。
定义泛型委托的基本语法如下：
public delegate TResult MyGenericDelegate(T1 arg1, T2 arg2); 在这个例子中，MyGenericDelegate 是一个泛型委托，它定义了两个输入参数 T1 和 T2，以及一个返回值 TResult。in 和 out 是泛型委托的变体修饰符，in 表示输入类型参数，out 表示输出类型参数。
例如，我们可以定义一个简单的泛型委托，用于处理两个参数并返回一个结果：
public delegate T AddDelegate(T a, T b); 这个委托可以用于处理任意类型的加法操作。例如，对于 int 类型和 string 类型，我们可以分别定义实现方法：
public static int AddInt(int a, int b)
{
return a + b;
}
public static string AddString(string a, string b)
{
return a + b;
}然后，我们可以将这些方法赋值给泛型委托：
AddDelegate intAdd = AddInt;
AddDelegate stringAdd = AddString; 通过定义泛型委托，我们可以编写更加通用的代码，而不需要为每种类型都单独定义委托。
5.2 使用泛型委托
泛型委托的使用非常灵活，它不仅可以用于方法的调用，还可以用于事件的定义和处理。以下是一些常见的使用场景：
方法调用
通过泛型委托，我们可以将不同类型的参数传递给委托，并调用相应的方法。例如，使用前面定义的 AddDelegate，我们可以这样调用方法：
int result1 = intAdd(1, 2); // 调用 AddInt 方法
string result2 = stringAdd("Hello", "World"); // 调用 AddString 方法这种方式不仅减少了代码量，还提高了代码的可读性和可维护性。
事件处理
泛型委托也可以用于事件的定义和处理。例如，我们可以定义一个泛型事件处理器委托：
public delegate void EventHandler(object sender, TEventArgs e); 然后，我们可以定义一个事件并使用泛型委托：
public class MyEventArgs : EventArgs
{
public string Message { get; set; }
}
public class MyEventPublisher
{
public event EventHandler MyEvent;
public void RaiseEvent()
{
MyEventArgs args = new MyEventArgs { Message = "Hello, World!" };
MyEvent?.Invoke(this, args);
}
} 在这个例子中，MyEvent 是一个泛型事件，它使用了 EventHandler 委托。我们可以通过订阅事件来处理事件：
public static void MyEventHandler(object sender, MyEventArgs e)
{
Console.WriteLine(e.Message);
}
MyEventPublisher publisher = new MyEventPublisher();
publisher.MyEvent += MyEventHandler;
publisher.RaiseEvent();通过使用泛型委托，我们可以编写更加通用和灵活的事件处理代码，从而提高代码的复用性和可维护性。
泛型委托的优势
使用泛型委托的主要优势包括：
-
类型安全：泛型委托可以确保在调用委托时传递的参数和返回值类型是正确的，避免了运行时的类型转换错误。
-
代码复用性：泛型委托可以用于处理不同类型的数据，而不需要为每种类型都单独定义委托，从而减少了代码量。
-
灵活性：泛型委托可以用于方法调用、事件处理等多种场景，提供了更高的灵活性和可扩展性。
通过合理使用泛型委托，我们可以编写出更加通用、灵活且类型安全的代码，从而提高开发效率和代码质量。
6. 泛型的约束
6.1 约束的类型
在 C# 泛型编程中，约束是通过 where 关键字来指定的，它能够限制泛型类型参数可以接受的类型范围，从而让泛型代码更加安全和灵活。C# 提供了多种约束类型，每种约束都有其特定的用途和限制。
-
基类约束：通过指定一个基类作为约束，可以确保泛型类型参数必须是该基类或其派生类。例如：
public class MyClasswhere T : MyBaseClass 这样，
T必须是MyBaseClass或其派生类。基类约束可以让泛型类或方法访问基类的成员，从而实现更复杂的逻辑。 -
接口约束：可以指定泛型类型参数必须实现某个接口或多个接口。例如：
public class MyClasswhere T : IMyInterface 或者：
public class MyClasswhere T : IMyInterface1, IMyInterface2 这样，
T必须实现IMyInterface或同时实现IMyInterface1和IMyInterface2。接口约束可以让泛型代码调用接口中的方法，从而实现多态。 -
构造函数约束：如果需要在泛型类或方法中创建类型参数的实例，可以使用
new()约束。例如：public class MyClasswhere T : new() 这样，
T必须有一个无参数的公共构造函数。构造函数约束使得可以在泛型代码中使用new T()来创建实例。 -
值类型约束：通过
struct约束，可以限制泛型类型参数必须是值类型。例如：public class MyClasswhere T : struct 这样，
T必须是值类型（如int、double等）。值类型约束通常用于需要高性能的操作，因为值类型在堆栈上分配，访问速度更快。 -
引用类型约束：通过
class约束，可以限制泛型类型参数必须是引用类型。例如：public class MyClasswhere T : class 这样，
T必须是引用类型（如string、自定义类等）。引用类型约束通常用于需要引用语义的场景，例如对象的引用传递。 -
非托管类型约束：通过
unmanaged约束，可以限制泛型类型参数必须是非托管类型。非托管类型是指不包含引用类型成员的值类型。例如：public class MyClasswhere T : unmanaged 这样，
T必须是非托管类型。非托管类型约束通常用于需要与非托管代码交互的场景，例如在高性能计算或底层系统编程中。
6.2 约束的应用
约束在泛型编程中具有重要的作用，它不仅可以提高代码的安全性和灵活性，还可以让泛型代码更加通用和高效。以下是一些常见的约束应用场景：
-
确保类型安全：通过约束，可以确保泛型类型参数符合特定的类型要求，从而避免运行时的类型错误。例如，如果一个泛型方法需要对类型参数进行排序，那么可以添加
IComparable接口约束：public static T GetMax(T a, T b) where T : IComparable { return a.CompareTo(b) > 0 ? a : b; } 这样，只有实现了
IComparable接口的类型才能作为参数传递给该方法，从而保证了代码的类型安全。 -
访问特定成员：约束可以让泛型代码访问类型参数的特定成员，从而实现更复杂的逻辑。例如，如果一个泛型类需要访问类型参数的某个属性，那么可以添加基类约束或接口约束：
public class MyClasswhere T : IMyInterface { public void PrintProperty(T item) { Console.WriteLine(item.MyProperty); } } 这样，
MyClass可以通过IMyInterface接口访问T的MyProperty属性。 -
创建实例：如果需要在泛型代码中创建类型参数的实例，可以使用
new()约束。例如：public class MyClasswhere T : new() { public T CreateInstance() { return new T(); } } 这样，
MyClass可以通过new T()创建T的实例。 -
提高性能：通过约束，可以选择更适合的类型来提高性能。例如，如果一个泛型方法需要处理大量数据，那么可以添加
struct约束来限制类型参数为值类型：public static T Add(T a, T b) where T : struct { return (dynamic)a + (dynamic)b; } 这样，
Add方法可以利用值类型的高性能特性，从而提高方法的执行效率。 -
实现多态：约束可以让泛型代码实现多态。例如，如果一个泛型类需要调用类型参数的某个方法，那么可以添加接口约束：
public class MyClasswhere T : IMyInterface { public void Execute(T item) { item.MyMethod(); } } 这样，
MyClass可以通过IMyInterface接口调用T的MyMethod方法，从而实现多态。 -
与非托管代码交互：非托管类型约束可以让泛型代码与非托管代码交互。例如，如果一个泛型方法需要处理非托管数据，那么可以添加
unmanaged约束：public static T Copy(T source, IntPtr destination) where T : unmanaged { unsafe { *(T*)destination = source; } return source; } 这样，
Copy方法可以将值类型T的数据复制到非托管内存中，从而实现与非托管代码的交互。
通过合理使用约束，可以编写出更加安全、灵活、通用和高效的泛型代码，从而提高开发效率和代码质量。
7. 泛型的性能优势
7.1 避免装箱与拆箱
在 C# 中，值类型（如 int、double 等）和引用类型（如 string、自定义类等）在内存中的存储方式不同。值类型存储在栈中，访问速度快；引用类型存储在堆中，通过引用访问，访问速度相对较慢。当值类型被赋值给对象类型（如 object）时，会发生装箱操作，即将值类型的数据复制到堆中，并创建一个引用指向它。相反，当需要从对象类型恢复为值类型时，会发生拆箱操作，即将堆中的数据复制回栈中。装箱和拆箱操作不仅会消耗额外的内存，还会降低程序的性能。
泛型的出现有效避免了装箱和拆箱操作。以 List 为例，当 T 是值类型时，List 会为值类型生成一个专用的类，直接在栈中操作值类型数据，而不会将其装箱到堆中。这大大减少了内存分配和数据复制的开销，从而提高了程序的性能。例如，使用泛型 List 存储整数时，与使用非泛型的 ArrayList 相比，性能提升显著。根据性能测试，对于大量数据的存储和操作，List 的性能比 ArrayList 高出数倍，尤其是在频繁访问和修改数据时，性能优势更加明显。
7.2 提高代码复用性
泛型的一个重要特性是可以编写通用的代码，而不需要为每种类型都单独编写逻辑。这不仅减少了代码量，还提高了代码的可维护性和扩展性。通过定义泛型类、方法、接口和委托，我们可以创建能够处理不同类型数据的代码，同时保持类型安全。例如，一个泛型方法 Print 可以处理任意类型的参数，无论是 int 还是 string，都无需重新编写方法。这种代码复用性不仅提高了开发效率，还减少了因重复代码带来的错误风险。
在实际开发中，泛型的代码复用性可以显著提高项目的开发速度和质量。例如，在一个大型项目中，可能需要处理多种类型的数据，如用户信息、订单信息、产品信息等。通过使用泛型类和方法，可以编写通用的数据处理逻辑，而不需要为每种类型都单独实现一套逻辑。这不仅减少了代码的冗余，还使得代码更加简洁和易于维护。此外，泛型的代码复用性还可以提高代码的可读性，使其他开发者更容易理解和使用代码。