深入解析 C# 中的泛型：概念、用法与最佳实践

news2025/3/10 1:02:57

C# 中的 泛型（Generics） 是一种强大的编程特性，允许开发者在不预先指定具体数据类型的情况下编写代码。通过泛型，C# 能够让我们编写更灵活、可重用、类型安全且性能优良的代码。泛型广泛应用于类、方法、接口、委托、集合等多个方面。

本文将详细介绍 C# 中泛型的基本概念、常见用法、类型约束以及一些高级应用，帮助你更深入地理解泛型的强大功能及其最佳实践。

一、泛型的基本概念

1.1 什么是泛型？

泛型使得你能够编写能够操作多种数据类型的代码，而不需要在代码中硬编码具体的数据类型。通过类型参数（例如 T），你可以在运行时决定具体的类型，从而提高代码的重用性和灵活性。

在 C# 中，泛型可以应用于：

泛型类
泛型方法
泛型接口
泛型委托
泛型集合

1.2 泛型类

泛型类 是在定义类时使用类型参数，并且在类的实例化时指定具体的类型。这使得同一个类可以用来处理不同类型的数据。

示例：

public class Box<T>
{
    private T _value;

    public void SetValue(T value)
    {
        _value = value;
    }

    public T GetValue()
    {
        return _value;
    }
}

public class Program
{
    public static void Main()
    {
        Box<int> intBox = new Box<int>();
        intBox.SetValue(123);
        Console.WriteLine(intBox.GetValue());  // 输出 123

        Box<string> stringBox = new Box<string>();
        stringBox.SetValue("Hello");
        Console.WriteLine(stringBox.GetValue());  // 输出 Hello
    }
}

在这个例子中，Box<T> 是一个泛型类，T 是类型参数。通过不同的类型参数，Box 类可以同时处理不同的数据类型。

1.3 泛型方法

泛型方法 允许你在方法定义时使用类型参数。方法可以在调用时决定具体的类型。

示例：

public class Program
{
    public static void Print<T>(T value)
    {
        Console.WriteLine(value);
    }

    public static void Main()
    {
        Print(123);      // 输出 123
        Print("Hello");  // 输出 Hello
        Print(3.14);     // 输出 3.14
    }
}

Print<T> 方法能够处理不同类型的数据，并且在调用时根据传入的参数类型来自动推断 T 的类型。

1.4 泛型接口

泛型接口 允许接口声明时不指定具体的类型，而是在实现该接口的类中指定具体类型。通过这种方式，接口可以与多种数据类型兼容。

示例：

public interface IStorage<T>
{
    void Add(T item);
    T Get(int index);
}

public class StringStorage : IStorage<string>
{
    private List<string> items = new List<string>();

    public void Add(string item)
    {
        items.Add(item);
    }

    public string Get(int index)
    {
        return items[index];
    }
}

public class Program
{
    public static void Main()
    {
        IStorage<string> storage = new StringStorage();
        storage.Add("Item 1");
        storage.Add("Item 2");
        Console.WriteLine(storage.Get(0));  // 输出 Item 1
    }
}

在这个例子中，IStorage<T> 是一个泛型接口，StringStorage 类实现了该接口，并且指定 T 为 string 类型。

二、泛型类型参数的约束

C# 允许你为泛型类型参数添加约束，以确保泛型在特定类型范围内使用，从而提升类型安全性。

2.1 常见的泛型约束

class：限制类型参数为引用类型。
struct：限制类型参数为值类型。
new()：限制类型参数必须有无参数构造函数。
where T : BaseClass：限制类型参数为某个特定的类或接口。

2.2 约束示例

示例1：限制类型为值类型

public class ValueTypeContainer<T> where T : struct
{
    private T _value;

    public ValueTypeContainer(T value)
    {
        _value = value;
    }

    public void Display()
    {
        Console.WriteLine(_value);
    }
}

public class Program
{
    public static void Main()
    {
        ValueTypeContainer<int> intContainer = new ValueTypeContainer<int>(123);
        intContainer.Display();  // 输出 123

        // 编译错误：不能传递引用类型
        // ValueTypeContainer<string> stringContainer = new ValueTypeContainer<string>("Hello");
    }
}

示例2：使用接口约束

public interface IComparable
{
    int CompareTo(object obj);
}

public class Repository<T> where T : IComparable
{
    public void Print(T item)
    {
        Console.WriteLine(item.ToString());
    }
}

public class Program
{
    public static void Main()
    {
        Repository<string> repo = new Repository<string>();
        repo.Print("Hello");  // 输出 Hello
    }
}

2.3 多个约束的使用

你可以为一个泛型类型参数指定多个约束，确保泛型类型满足多个条件。

示例：

public class Repository<T> where T : class, IComparable, new()
{
    public void Print(T item)
    {
        Console.WriteLine(item.ToString());
    }
}

三、泛型的高级用法

3.1 多个类型参数

泛型不仅支持一个类型参数，还可以支持多个类型参数，这使得你可以创建更加灵活的泛型类型。

示例：

public class Pair<T1, T2>
{
    private T1 first;
    private T2 second;

    public Pair(T1 first, T2 second)
    {
        this.first = first;
        this.second = second;
    }

    public void Print()
    {
        Console.WriteLine($"First: {first}, Second: {second}");
    }
}

public class Program
{
    public static void Main()
    {
        Pair<int, string> pair = new Pair<int, string>(1, "One");
        pair.Print();  // 输出 First: 1, Second: One
    }
}

3.2 泛型与集合类

C# 的泛型集合类（如 List<T>、Dictionary<TKey, TValue>、Queue<T> 等）允许我们高效地操作数据，并且避免了类型转换的潜在问题。

示例：

List<int> numbers = new List<int>();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
Console.WriteLine(numbers[0]);  // 输出 1

3.3 泛型委托

泛型委托使得委托能够处理多种类型的方法。你可以定义一个泛型委托，使其接受不同类型的参数，并且在运行时动态选择具体的方法。

示例：

public delegate void PrintDelegate<T>(T value);

public class Program
{
    public static void Main()
    {
        PrintDelegate<int> printInt = (value) => Console.WriteLine(value);
        printInt(10);  // 输出 10

        PrintDelegate<string> printString = (value) => Console.WriteLine(value);
        printString("Hello");  // 输出 Hello
    }
}

3.4 泛型与 LINQ

C# 的 LINQ 查询使用泛型来确保查询结果的类型安全。你可以利用 LINQ 对集合进行高效的查询、排序和过滤操作。

示例：

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();

foreach (var num in evenNumbers)
{
    Console.WriteLine(num);  // 输出 2, 4
}