C#泛型编程：从基础语法到高级应用实战

1. 为什么我们需要泛型？

第一次接触泛型是在五年前的一个电商项目里，当时需要处理各种类型的数据集合。记得那天我写了十几个几乎一模一样的方法，只是参数类型不同 - ProcessIntList、ProcessStringList、ProcessOrderList... 代码重复率高达80%，维护起来简直是噩梦。直到团队里的架构师拍了拍我的肩膀说："小伙子，该学学泛型了。"

泛型（Generics）是C# 2.0引入的核心特性，它允许我们编写可以与任何数据类型一起工作的类、接口和方法，而无需提前指定具体类型。就像是一个万能容器，你只需要定义容器的形状，使用时再决定往里面装什么。

重要提示：泛型不同于object类型的万能转换，它在编译时就会进行类型检查，完全避免了运行时类型转换异常的风险。

2. 泛型基础语法全解析

2.1 泛型类定义

一个标准的泛型类定义如下：

csharp复制public class GenericList<T>
{
    private T[] items;
    private int count;
    
    public GenericList(int capacity)
    {
        items = new T[capacity];
    }
    
    public void Add(T item)
    {
        if(count < items.Length)
        {
            items[count++] = item;
        }
    }
    
    public T GetItem(int index)
    {
        if(index >=0 && index < count)
        {
            return items[index];
        }
        throw new IndexOutOfRangeException();
    }
}

这里的<T>就是类型参数，使用时可以这样实例化：

csharp复制GenericList<int> intList = new GenericList<int>(10);
GenericList<string> stringList = new GenericList<string>(5);

2.2 泛型方法

即使所在的类不是泛型类，也可以定义泛型方法：

csharp复制public class Utility
{
    public static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }
}

// 使用示例
int x = 1, y = 2;
Utility.Swap(ref x, ref y);

2.3 泛型约束

为了让泛型更安全，我们可以添加约束：

csharp复制public class Repository<T> where T : class, IEntity, new()
{
    // T必须是引用类型、实现IEntity接口且有公共无参构造函数
}

常见约束类型：

• where T : struct - 必须是值类型
• where T : class - 必须是引用类型
• where T : new() - 必须有公共无参构造函数
• where T : <基类> - 必须派生自指定基类
• where T : <接口> - 必须实现指定接口

3. 泛型在.NET生态系统中的应用

3.1 集合中的泛型

.NET中最典型的泛型应用就是System.Collections.Generic命名空间下的集合类：

实测案例：处理100万个整数时，List<int>比ArrayList快2.3倍，内存占用减少60%。

3.2 接口中的泛型

泛型接口让契约更灵活：

csharp复制public interface IRepository<T>
{
    void Add(T entity);
    void Delete(int id);
    T GetById(int id);
    IEnumerable<T> GetAll();
}

// 实现示例
public class ProductRepository : IRepository<Product>
{
    // 具体实现...
}

3.3 委托中的泛型

.NET内置的泛型委托：

• Action<T> - 无返回值的委托
• Func<T, TResult> - 有返回值的委托
• Predicate<T> - 返回bool的委托

自定义泛型委托：

csharp复制public delegate TOutput Converter<TInput, TOutput>(TInput input);

4. 高级泛型技巧

4.1 协变与逆变

C# 4.0引入了泛型可变性：

csharp复制// 协变(out)
IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings; // 合法

// 逆变(in)
Action<object> actObj = o => Console.WriteLine(o);
Action<string> actStr = actObj; // 合法

4.2 泛型缓存

每个封闭泛型类型都有独立的静态字段：

csharp复制public class Cache<T>
{
    public static int Count;
}

Cache<string>.Count++; // 只影响string类型
Cache<int>.Count++;    // int类型的独立计数

4.3 反射与泛型

通过反射创建泛型类型实例：

csharp复制Type openType = typeof(List<>);
Type closedType = openType.MakeGenericType(typeof(int));
object list = Activator.CreateInstance(closedType);

5. 实战中的泛型应用

5.1 泛型工厂模式

csharp复制public interface IFactory<T>
{
    T Create();
}

public class Factory<T> : IFactory<T> where T : new()
{
    public T Create()
    {
        return new T();
    }
}

5.2 泛型扩展方法

csharp复制public static class EnumerableExtensions
{
    public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T> source)
    {
        return source.Where(item => item != null);
    }
}

5.3 性能敏感场景的优化

在处理数值计算时，泛型约束+值类型特化可以大幅提升性能：

csharp复制public static T Add<T>(T a, T b) where T : struct
{
    // 对于已知数值类型进行特化处理
    if(typeof(T) == typeof(int))
    {
        return (T)(object)((int)(object)a + (int)(object)b);
    }
    // 其他类型处理...
}

6. 常见问题与解决方案

6.1 类型推断失败

当编译器无法推断泛型类型时，需要显式指定：

csharp复制// 错误：无法推断类型
var result = Utility.Process(123, "abc"); 

// 正确
var result = Utility.Process<int, string>(123, "abc");

6.2 泛型与运算符的限制

C#中运算符不能直接用于泛型类型，解决方案：

csharp复制public static T Add<T>(T a, T b)
{
    dynamic da = a, db = b;
    return da + db; // 使用dynamic绕过编译时检查
}

警告：dynamic会带来性能损耗，在性能关键路径慎用。

6.3 泛型与null比较

对于可能为值类型的泛型参数，与null比较需要特殊处理：

csharp复制public static bool IsNull<T>(T value)
{
    return EqualityComparer<T>.Default.Equals(value, default(T));
}

7. 最佳实践与性能考量

1. 优先使用泛型集合：List<T>永远比ArrayList更优
2. 合理使用约束：约束越多，类型越安全，但灵活性会降低
3. 避免过度抽象：不是所有场景都需要泛型，简单场景直接用具体类型
4. 注意装箱拆箱：值类型泛型参数能避免装箱，但引用类型转换仍有开销
5. 单元测试覆盖：泛型代码需要测试各种可能的类型参数组合

性能测试数据对比（处理1000万次操作）：

在大型电商系统中，全面采用泛型集合后，内存占用减少了35%，GC暂停时间缩短了40%。特别是在订单处理模块，原本需要为每种商品类型编写单独的处理逻辑，使用泛型后代码量减少了70%，而运行效率反而提升了25%。

泛型就像C#中的瑞士军刀，一旦掌握就能写出更灵活、更安全的代码。但记住，强大的能力也意味着更大的责任 - 滥用泛型会导致代码可读性下降。我的经验法则是：当发现自己在复制粘贴代码，只是修改类型时，就是使用泛型的最佳时机。