C#的泛型是什么？如何使用？

object

System.Collections.ArrayList

ArrayList

object

int

List<T>

T

List<int>

int

int

object

object

is

as

GenericCalculator<T>

T

T

IAdditionCapable<T>

List<int>

int

object

List<T>

Dictionary<TKey, TValue>

// 定义一个简单的泛型盒子类
public class GenericBox<T>
{
    private T _content; // 存储任意类型的内容

    public GenericBox(T content)
    {
        _content = content;
    }

    public T GetContent()
    {
        return _content;
    }

    public void SetContent(T newContent)
    {
        _content = newContent;
    }

    public void DisplayContentType()
    {
        Console.WriteLine($"Box contains type: {_content.GetType().Name}");
    }
}

// 如何使用泛型类
// 存储一个整数
GenericBox<int> intBox = new GenericBox<int>(123);
Console.WriteLine($"Int Box Content: {intBox.GetContent()}"); // 输出: Int Box Content: 123
intBox.DisplayContentType(); // 输出: Box contains type: Int32

// 存储一个字符串
GenericBox<string> stringBox = new GenericBox<string>("Hello Generics!");
Console.WriteLine($"String Box Content: {stringBox.GetContent()}"); // 输出: String Box Content: Hello Generics!
stringBox.DisplayContentType(); // 输出: Box contains type: String

// 尝试将字符串放入整数盒子（编译时错误！）
// intBox.SetContent("Oops"); // 这行代码会引发编译错误，因为它期望一个 int

GenericBox<T>

T

GenericBox<int>

T

int

GenericBox<string>

T

string

public class Utility
{
    // 定义一个泛型方法，用于交换两个变量的值
    public static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    // 另一个泛型方法，用于比较两个值是否相等
    public static bool AreEqual<T>(T value1, T value2)
    {
        // 对于引用类型，默认的Equals方法会比较引用；
        // 对于值类型，会比较值。
        // 对于自定义类型，需要重写Equals方法。
        return value1.Equals(value2);
    }
}

// 如何使用泛型方法
int num1 = 10, num2 = 20;
Console.WriteLine($"Before swap: num1={num1}, num2={num2}"); // 输出: Before swap: num1=10, num2=20
Utility.Swap(ref num1, ref num2); // 编译器会自动推断 T 为 int
Console.WriteLine($"After swap: num1={num1}, num2={num2}");  // 输出: After swap: num1=20, num2=10

string str1 = "Apple", str2 = "Banana";
Console.WriteLine($"Before swap: str1={str1}, str2={str2}"); // 输出: Before swap: str1=Apple, str2=Banana
Utility.Swap(ref str1, ref str2); // 编译器会自动推断 T 为 string
Console.WriteLine($"After swap: str1={str1}, str2={str2}");  // Output: After swap: str1=Banana, str2=Apple

Console.WriteLine($"Are 5 and 5 equal? {Utility.AreEqual(5, 5)}"); // 输出: True
Console.WriteLine($"Are 'hello' and 'world' equal? {Utility.AreEqual("hello", "world")}"); // 输出: False

T

T

object

Equals()

ToString()

T

T

T

where

T

T

T

T

object

T

CompareTo

object

CompareTo

T

IComparable<T>

public class GenericSorter
{
    // 这是一个没有约束的泛型方法，无法直接比较T
    // public static T GetMax<T>(T a, T b) 
    // {
    //     // 编译错误：'T' 不包含 'CompareTo' 的定义
    //     if (a.CompareTo(b) > 0) return a; 
    //     return b;
    // }

    // 使用 IComparable<T> 约束，允许比较
    public static T GetMax<T>(T a, T b) where T : IComparable<T>
    {
        if (a.CompareTo(b) > 0)
        {
            return a;
        }
        return b;
    }

    // 使用 new() 约束，允许创建实例
    public static T CreateAndInitialize<T>() where T : new()
    {
        T instance = new T();
        // 假设T有一个名为Initialize的公共方法，但这里还需要接口约束
        // instance.Initialize(); 
        return instance;
    }
}

// 使用示例
int maxInt = GenericSorter.GetMax(5, 10); // maxInt = 10
string maxString = GenericSorter.GetMax("apple", "banana"); // maxString = "banana"

// 假设我们有一个 Person 类，它实现了无参数构造函数
public class Person
{
    public string Name { get; set; } = "Unknown";
    public Person() { }
    public Person(string name) { Name = name; }
}

Person newPerson = GenericSorter.CreateAndInitialize<Person>();
Console.WriteLine($"New person's name: {newPerson.Name}"); // 输出: New person's name: Unknown