在C#的广阔世界里，有一项特性能够让开发人员编写出更简洁、更可复用且类型安全的代码，那就是泛型。
泛型常被誉为C#语言中最强大的特性之一，它使开发人员能够通过将类型指定推迟到运行时来创建灵活且高效的代码。在本文中，我们将通过实际场景来深入探究泛型的方方面面，助你成为泛型方面的高手。
为什么泛型很重要？
我们先来解答一个常被问到的问题：为什么要关注泛型呢？
泛型具有三个关键优势：
类型安全： 它们消除了强制类型转换的需求，并通过在编译时执行类型检查来防止代码出现运行时错误。
性能： 由于泛型避免了对值类型进行装箱和拆箱的开销，所以能让应用程序性能更佳。
代码可复用性： 你可以创建适用于任何数据类型的算法，无需编写冗余代码。
现在，让我们通过实际的代码示例深入了解泛型在现实世界中的应用情况。
场景1：实际应用中的泛型仓储模式
假设你正在开发一个电子商务应用程序，并且有多种类型的实体（例如，产品、客户、订单）。一个常见的需求是能够对这些实体执行增删改查（CRUD）操作。如果不使用泛型，你最终会为每个实体编写冗余的代码。
不使用泛型时：
public class ProductRepository
{
public void Add(Product product) { /* 将产品添加到数据库 */ }
public Product GetById(int id) { /* 通过ID获取产品 */ }
public void Update(Product product) { /* 更新产品 */ }
public void Delete(int id) { /* 删除产品 */ }
}
public class CustomerRepository
{
public void Add(Customer customer) { /* 将客户添加到数据库 */ }
public Customer GetById(int id) { /* 通过ID获取客户 */ }
public void Update(Customer customer) { /* 更新客户 */ }
public void Delete(int id) { /* 删除客户 */ }
}
在这里，我们基本上是在不同的类中重复相同的操作，违背了“不要重复自己”（DRY）原则。
使用泛型时：
public class Repository<T> where T : class
{
public void Add(T entity) { /* 将实体添加到数据库 */ }
public T GetById(int id) { /* 通过ID获取实体 */ }
public void Update(T entity) { /* 更新实体 */ }
public void Delete(int id) { /* 删除实体 */ }
}
通过使用泛型，我们现在有了一个单一的Repository<T>类，它可以处理任何实体类型（产品、客户、订单等等），从而使代码更简洁且更易于维护。再也不用为每个实体复制粘贴仓储方法了！
进阶提示：扩展泛型仓储💡 在实际应用中，你可能想为某些实体添加特定的行为。可以像这样扩展泛型仓储：
public class ProductRepository : Repository<Product>
{
public IEnumerable<Product> GetProductsByCategory(int categoryId)
{
// 按类别查询产品的自定义查询
}
}
场景2：用于灵活性和控制的泛型约束
C#泛型的一个强大特性是约束。它们允许你指定泛型类型参数必须满足某些要求，例如实现某个接口或继承自特定的类。
考虑为你的应用程序提供一个日志记录服务。你可能希望确保只有实现了ILoggable接口的实体才能传递到日志记录方法中。如果没有约束，你就不得不依赖运行时类型检查，这并不理想。
定义泛型约束：
public interface ILoggable
{
string LogDetails();
}
public class Logger<T> where T : ILoggable
{
public void Log(T entity)
{
Console.WriteLine(entity.LogDetails());
}
}
现在，当你尝试记录一个未实现ILoggable接口的对象时，编译器就会报错，从而确保了编译时的类型安全。
用法：
public class Product : ILoggable
{
public string Name { get; set; }
public decimal Price { get; set; }
public string LogDetails()
{
return $"Product: {Name}, Price: {Price}";
}
}
var logger = new Logger<Product>();
var product = new Product { Name = "Laptop", Price = 999.99M };
logger.Log(product); // 输出：Product: Laptop, Price: 999.99
场景3：用于可复用性的泛型方法
有时候，你并不需要整个类都是泛型的，而只是希望一个或多个方法能处理任何类型。这正是泛型方法的用武之地。
例如，考虑一个API响应处理程序，其响应体可能是任何类型（例如，字符串、整数或自定义对象）。如果不使用泛型，你可能最终会为处理每种类型编写单独的方法。
不使用泛型时：
public string HandleStringResponse(string response) { /* 处理字符串响应 */ }
public int HandleIntResponse(int response) { /* 处理整数响应 */ }
// 依此类推，每种类型都要写相应方法...
使用泛型方法时：
public T HandleResponse<T>(T response)
{
// 处理响应并返回
return response;
}
用法：
string strResponse = HandleResponse("Success");
int intResponse = HandleResponse(200);
在这里，HandleResponse<T>可以接受任何类型并返回相同类型，这使得该方法既灵活又可复用。
实际应用：缓存响应 缓存是许多应用程序中的常见需求，但被缓存的对象类型可能各不相同。泛型可以在不丢失类型安全的情况下使缓存更具灵活性。
public class CacheService
{
private readonly Dictionary<string, object> _cache = new Dictionary<string, object>();
public void SetCache<T>(string key, T value)
{
_cache[key] = value;
}
public T GetCache<T>(string key)
{
if (_cache.TryGetValue(key, out var value))
{
return (T)value;
}
return default;
}
}
现在，无论你是缓存一个产品、一个List<Customer>还是一个简单的字符串，同一个CacheService都可以处理。
var cacheService = new CacheService();
cacheService.SetCache("product_1", new Product { Name = "Phone", Price = 499.99M });
var cachedProduct = cacheService.GetCache<Product>("product_1");
场景4：泛型中的协变和逆变
协变和逆变在泛型中处理继承层次结构时能提供更大的灵活性。为了说明这一点，假设我们有以下继承层次结构：
public class Animal { }
public class Dog : Animal { }
public class Cat : Animal { }
协变允许你用派生程度更高的类型（如Dog）来替代派生程度较低的类型（Animal），而逆变则允许相反的操作。
协变的实际应用： 协变在诸如从方法返回值之类的场景中很有用。例如，在使用像IEnumerable<T>这样的接口时可以使用协变：
IEnumerable<Dog> dogs = new List<Dog>();
IEnumerable<Animal> animals = dogs; // 由于协变，这是可行的
逆变的实际应用： 逆变在传递参数时很有用。例如，你可以在委托操作中使用它：
Action<Animal> action = a => Console.WriteLine(a.GetType().Name);
Action<Dog> dogAction = action; // 由于逆变，这是可行的
尽管协变和逆变看起来像是比较小众的概念，但理解它们能够对泛型进行更高级的操作，特别是在涉及复杂层次结构的场景中。
场景5：泛型与依赖注入
泛型在依赖注入（DI）中起着不可或缺的作用，尤其是在处理不同类型之间具有相似行为的服务时。一个常见的实际场景是针对不同实体的日志记录或验证服务。
例如，假设我们想为我们的实体创建一个通用的验证器：
public interface IValidator<T>
{
bool Validate(T entity);
}
public class ProductValidator : IValidator<Product>
{
public bool Validate(Product product)
{
return product.Price > 0;
}
}
在依赖注入的设置中（如ASP.NET Core），我们可以像这样注册和解析泛型服务：
services.AddScoped(typeof(IValidator<>), typeof(ProductValidator));
这使得代码更简洁、更模块化且更易于测试。
泛型是现代C#开发的基石。它们使你能够编写可复用、类型安全且高效的代码，这些代码能够适应不同类型，同时又不牺牲可维护性。通过利用诸如仓储模式、缓存机制和依赖注入等实际场景，你可以充分发挥泛型的强大功能来简化代码库并提升应用程序性能。
如果你喜欢我的文章，请给我一个赞！谢谢
