C# 编程学习的泛型编程高级应用

xiaoshi 05-30 28 抢沙发

默认

摘要： ...

C#泛型编程高级应用：提升代码复用与类型安全

在C#开发中，泛型编程是一项强大的技术，它不仅能显著提升代码的复用性，还能在编译阶段就确保类型安全。本文将深入探讨C#泛型的高级应用技巧，帮助开发者编写更优雅、更高效的代码。

泛型基础回顾与核心优势

泛型是.NET框架2.0引入的重要特性，它允许我们编写可以与多种数据类型一起工作的类、接口和方法，而不必为每种类型编写重复代码。与传统的Object基类方式相比，泛型避免了装箱拆箱的性能损耗，同时提供了编译时类型检查。

// 传统非泛型集合
ArrayList list = new ArrayList();
list.Add(1); // 装箱
int num = (int)list[0]; // 拆箱

// 泛型集合
List<int> genericList = new List<int>();
genericList.Add(1); // 无装箱
int num = genericList[0]; // 无拆箱

泛型的核心优势在于：

类型安全：编译时就能捕获类型不匹配的错误
性能提升：避免了值类型的装箱拆箱操作
代码复用：一套代码可以处理多种数据类型

高级泛型约束技巧

泛型约束是提升泛型灵活性的关键。通过where子句，我们可以对类型参数施加各种限制，确保它们具备我们需要的特性。

public class Repository<T> where T : class, IEntity, new()
{
    public void Add(T entity)
    {
        // 实现添加逻辑
    }

    public T GetById(int id)
    {
        // 实现查询逻辑
        return new T(); // 需要new()约束
    }
}

常见的约束类型包括：

接口约束：要求类型实现特定接口
基类约束：要求类型派生自特定基类
构造函数约束：要求类型有无参构造函数
值类型/引用类型约束：struct或class约束

更复杂的约束可以通过组合实现：

public T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

协变与逆变在泛型中的应用

C# 4.0引入了泛型接口和委托的协变(out)和逆变(in)支持，这使得泛型类型在继承关系上更加灵活。

协变示例：

IEnumerable<Derived> derived = new List<Derived>();
IEnumerable<Base> bases = derived; // 协变允许

逆变示例：

Action<Base> actBase = (b) => Console.WriteLine(b);
Action<Derived> actDerived = actBase; // 逆变允许

理解协变和逆变的关键在于：

协变(out)：子类可以安全转换为父类（输出位置）
逆变(in)：父类可以安全转换为子类（输入位置）

泛型缓存与性能优化

利用静态字段的特性，我们可以实现高效的泛型类型缓存机制。每个封闭的泛型类型都有自己独立的静态字段，这为类型特定的缓存提供了可能。

public class Cache<T>
{
    private static readonly ConcurrentDictionary<string, T> _cache 
        = new ConcurrentDictionary<string, T>();

    public static T GetOrAdd(string key, Func<T> valueFactory)
    {
        return _cache.GetOrAdd(key, k => valueFactory());
    }
}

这种模式在以下场景特别有用：

类型特定的配置信息缓存
避免重复计算的昂贵操作
共享资源的类型级别管理

泛型与反射的高级结合

反射API提供了丰富的泛型类型操作方法，我们可以动态创建和操作泛型类型。

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

高级应用场景包括：

插件系统中动态加载泛型类型
序列化/反序列化泛型数据结构
依赖注入容器中的泛型解析

设计模式中的泛型实践

泛型可以显著简化许多设计模式的实现，使其更加类型安全和优雅。

泛型工厂模式：

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

public class CarFactory : IFactory<Car>
{
    public Car Create() => new Car();
}

泛型策略模式：

public interface ISortingStrategy<T>
{
    void Sort(List<T> items);
}

public class QuickSortStrategy<T> : ISortingStrategy<T> where T : IComparable<T>
{
    public void Sort(List<T> items)
    {
        // 实现快速排序
    }
}

泛型装饰器模式：

public class LoggingRepository<T> : IRepository<T>
{
    private readonly IRepository<T> _inner;

    public LoggingRepository(IRepository<T> inner)
    {
        _inner = inner;
    }

    public void Add(T entity)
    {
        Console.WriteLine($"Adding {typeof(T).Name}");
        _inner.Add(entity);
    }
}

泛型在异步编程中的应用

结合async/await，泛型可以创建类型安全的异步操作管道。

public async Task<TResult> RetryAsync<TResult>(Func<Task<TResult>> func, int retryCount)
{
    while (true)
    {
        try
        {
            return await func();
        }
        catch when (retryCount-- > 0)
        {
            await Task.Delay(1000);
        }
    }
}