C# 面试问题高级：046 - 什么是泛型类 （GenericList＜T＞）

在C#中，泛型（Generics）是一种强大的特性，它允许编写与类型无关的代码。通过使用泛型，开发者可以创建可重用的、类型安全的类和方法，而无需为每种数据类型重复编写代码。泛型类是泛型的一种常见形式，它们可以接受一个或多个类型参数，并在运行时根据具体的类型进行实例化。

什么是泛型类？

定义

泛型类（Generic Class）是一种可以接受一个或多个类型参数的类。这些类型参数在类定义时是未知的，但在实例化时由具体的类型替换。泛型类的主要目的是提高代码的重用性、类型安全性和性能。

基本概念

1. 类型参数：在泛型类定义中使用的占位符，表示类的实际类型。通常使用大写字母如T、U等表示。
2. 类型约束：可以对类型参数施加约束，以限制它可以接受的类型范围。例如，可以要求类型参数必须实现某个接口或继承自某个基类。
3. 实例化：在使用泛型类时，需要指定具体类型来替换类型参数。

示例场景

假设我们需要开发一个简单的集合类，用于存储不同类型的元素。如果我们不使用泛型类，就需要为每种数据类型分别编写不同的集合类，这不仅增加了代码量，还容易导致类型转换错误。使用泛型类可以帮助我们编写通用的集合类，适用于多种数据类型。

泛型类的实现

下面我们将通过一个具体的例子来展示如何在C#中实现泛型类。

定义泛型类

首先，我们定义一个简单的泛型类GenericList<T>，用于存储和操作一组元素。

// GenericList.cs
public class GenericList<T>
{
    private T[] items;
    private int count;

    // 构造函数，初始化数组大小
    public GenericList(int size)
    {
        items = new T[size];
        count = 0;
    }

    // 添加元素到列表
    public void Add(T item)
    {
        if (count < items.Length)
        {
            items[count] = item;
            count++;
        }
        else
        {
            throw new InvalidOperationException("列表已满");
        }
    }

    // 获取指定索引处的元素
    public T GetItem(int index)
    {
        if (index >= 0 && index < count)
        {
            return items[index];
        }
        else
        {
            throw new ArgumentOutOfRangeException(nameof(index), "索引超出范围");
        }
    }

    // 获取列表中的元素数量
    public int Count => count;
}

使用泛型类

现在，我们在主程序中使用上述泛型类，并观察其行为。

// Program.cs
class Program
{
    static void Main(string[] args)
    {
        // 创建一个存储整数的列表
        var intList = new GenericList<int>(5);
        intList.Add(1);
        intList.Add(2);
        intList.Add(3);

        Console.WriteLine($"整数列表中有 {intList.Count} 个元素");

        for (int i = 0; i < intList.Count; i++)
        {
            Console.WriteLine($"元素 {i}: {intList.GetItem(i)}");
        }

        // 创建一个存储字符串的列表
        var stringList = new GenericList<string>(3);
        stringList.Add("Hello");
        stringList.Add("World");

        Console.WriteLine($"\n字符串列表中有 {stringList.Count} 个元素");

        for (int i = 0; i < stringList.Count; i++)
        {
            Console.WriteLine($"元素 {i}: {stringList.GetItem(i)}");
        }
    }
}

执行结果

运行上述代码后，输出结果如下：

整数列表中有 3 个元素
元素 0: 1
元素 1: 2
元素 2: 3

字符串列表中有 2 个元素
元素 0: Hello
元素 1: World

泛型类的高级用法

为了更好地理解泛型类的高级用法，我们可以进一步扩展上面的例子，引入更多复杂的场景和功能。

类型约束

有时我们需要对泛型类的类型参数施加一些约束，以确保它们满足某些条件。C#提供了多种类型约束，包括基类约束、接口约束、构造函数约束等。

以下是如何使用类型约束的示例：

// GenericListWithConstraints.cs
public class GenericListWithConstraints<T> where T : IComparable<T>
{
    private T[] items;
    private int count;

    public GenericListWithConstraints(int size)
    {
        items = new T[size];
        count = 0;
    }

    public void Add(T item)
    {
        if (count < items.Length)
        {
            items[count] = item;
            count++;
        }
        else
        {
            throw new InvalidOperationException("列表已满");
        }
    }

    public T GetItem(int index)
    {
        if (index >= 0 && index < count)
        {
            return items[index];
        }
        else
        {
            throw new ArgumentOutOfRangeException(nameof(index), "索引超出范围");
        }
    }

    public int Count => count;

    // 新增方法：查找列表中最大值
    public T FindMax()
    {
        if (count == 0)
        {
            throw new InvalidOperationException("列表为空");
        }

        T max = items[0];
        for (int i = 1; i < count; i++)
        {
            if (items[i].CompareTo(max) > 0)
            {
                max = items[i];
            }
        }
        return max;
    }
}

在这个例子中，我们对类型参数T施加了IComparable<T>接口约束，这样我们就可以调用CompareTo方法来比较两个对象。

使用类型约束

现在，我们在主程序中使用带有类型约束的泛型类，并观察其行为。

// Program.cs
class Program
{
    static void Main(string[] args)
    {
        // 创建一个存储整数的列表
        var intList = new GenericListWithConstraints<int>(5);
        intList.Add(1);
        intList.Add(2);
        intList.Add(3);

        Console.WriteLine($"整数列表中的最大值: {intList.FindMax()}");

        // 创建一个存储字符串的列表
        var stringList = new GenericListWithConstraints<string>(3);
        stringList.Add("Apple");
        stringList.Add("Banana");
        stringList.Add("Cherry");

        Console.WriteLine($"\n字符串列表中的最大值: {stringList.FindMax()}");
    }
}

执行结果

运行上述代码后，输出结果如下：

整数列表中的最大值: 3

字符串列表中的最大值: Cherry

多个类型参数

有时我们需要使用多个类型参数来定义泛型类。以下是如何定义和使用具有多个类型参数的泛型类的示例：

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

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

    public T1 First
    {
        get { return first; }
        set { first = value; }
    }

    public T2 Second
    {
        get { return second; }
        set { second = value; }
    }

    public override string ToString()
    {
        return $"({first}, {second})";
    }
}

使用多个类型参数

现在，我们在主程序中使用具有多个类型参数的泛型类，并观察其行为。

// Program.cs
class Program
{
    static void Main(string[] args)
    {
        // 创建一个存储整数和字符串的配对
        var pair = new Pair<int, string>(1, "One");
        Console.WriteLine(pair.ToString());

        // 修改配对的值
        pair.First = 2;
        pair.Second = "Two";
        Console.WriteLine(pair.ToString());
    }
}

执行结果

运行上述代码后，输出结果如下：

(1, One)
(2, Two)

泛型方法

除了泛型类，C#还支持泛型方法。泛型方法可以在类中定义，也可以作为静态方法独立存在。以下是如何定义和使用泛型方法的示例：

public class Utility
{
    // 泛型方法：交换两个元素的值
    public static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    // 泛型方法：返回数组中的最大值
    public static T Max<T>(params T[] items) where T : IComparable<T>
    {
        if (items.Length == 0)
        {
            throw new ArgumentException("数组不能为空");
        }

        T max = items[0];
        for (int i = 1; i < items.Length; i++)
        {
            if (items[i].CompareTo(max) > 0)
            {
                max = items[i];
            }
        }
        return max;
    }
}

使用泛型方法

现在，我们在主程序中使用泛型方法，并观察其行为。

// Program.cs
class Program
{
    static void Main(string[] args)
    {
        // 测试 Swap 方法
        int x = 1, y = 2;
        Console.WriteLine($"交换前: x = {x}, y = {y}");
        Utility.Swap(ref x, ref y);
        Console.WriteLine($"交换后: x = {x}, y = {y}");

        // 测试 Max 方法
        int[] numbers = { 1, 2, 3, 4, 5 };
        Console.WriteLine($"\n数组中的最大值: {Utility.Max(numbers)}");

        string[] words = { "apple", "banana", "cherry" };
        Console.WriteLine($"字符串数组中的最大值: {Utility.Max(words)}");
    }
}

执行结果

运行上述代码后，输出结果如下：

交换前: x = 1, y = 2
交换后: x = 2, y = 1

数组中的最大值: 5
字符串数组中的最大值: cherry

泛型类的应用场景

泛型类在许多实际应用场景中都非常有用，以下是一些常见的应用场景：

1. 集合类：如前面的例子所示，泛型类非常适合用于实现集合类，如列表、栈、队列等。通过使用泛型类，可以避免为每种数据类型编写不同的集合类。
2. 算法库：泛型类可以用于实现通用算法，如排序、搜索等。通过使用泛型类，可以使这些算法适用于多种数据类型。
3. 数据访问层：在数据访问层中，泛型类可以用于实现通用的数据访问模式，如CRUD操作。通过使用泛型类，可以使数据访问逻辑更加简洁和易于维护。
4. API设计：在设计API时，使用泛型类可以帮助开发者明确哪些参数或返回值可能是特定类型，从而提高API的健壮性和可维护性。

泛型类的优点和缺点

优点

1. 代码重用性：通过使用泛型类，可以编写适用于多种数据类型的通用代码，减少了重复代码的数量。
2. 类型安全性：泛型类提供了编译时类型检查，避免了类型转换错误的发生，提高了代码的安全性。
3. 性能优化：由于泛型类在编译时就确定了具体的类型，因此可以避免运行时的类型转换，提高了性能。
4. 灵活性：通过使用类型约束，可以对泛型类的类型参数施加限制，使得泛型类更加灵活和强大。

缺点

1. 复杂性增加：对于小型项目，使用泛型类可能会引入不必要的复杂性。
2. 学习曲线：泛型类有一定的学习曲线，开发者需要花费时间掌握其概念和使用方法。
3. 性能问题：在某些情况下，使用泛型类可能导致性能下降，特别是在频繁创建和销毁对象的情况下。

总结

泛型类（Generic Class）是一项非常强大的特性，它能够有效地提高代码的重用性、类型安全性和性能。通过使用泛型类，开发者可以编写通用的、类型安全的代码，适用于多种数据类型。在实际开发中，泛型类常用于处理复杂的业务逻辑，尤其是在需要在多个对象之间进行依赖管理和功能扩展的情况下。它可以显著减少代码中的耦合部分，提升代码的可读性和可维护性。