<think>我们被要求解释
C#泛型(
Generic)的作用，并提供代码示例和解释。然后按照格式提出相关问题。
泛型是
C#中一个强大的特性，它允许我们编写可以适用于多种数据类
型的类、方法、接口等，而无需为每种类
型单独编写代码。
泛型的主要作用是提高代码的重用性、类
型安全性和性能。
作用：
1. 代码重用：编写一次，适用于多种类
型。
2. 类
型安全：在编译时进行类
型检查，避免运行时类
型转换错误。
3. 性能：避免装箱和拆箱操作（对于值类
型），提高性能。
常见
泛型应用：
泛型类、
泛型方法、
泛型接口、
泛型委托。
下面通过几个示例来展示
泛型的使用。</think>###
C#泛型(
Generic)的作用详解
泛型是
C#中的核心特性，允许你编写可重用的代码组件，这些组件可以处理不同类
型的数据，而无需为每种类
型单独实现。
泛型的主要作用是提供**类
型安全**和**代码重用**，同时避免装箱拆箱带来的性能损耗。
####
泛型的六大核心作用
1. **类
型安全性**
- 编译时类
型检查，避免运行时类
型转换错误
- 消除强制类
型转换的需要
2. **代码重用**
- 单个
泛型实现可处理多种数据类
型
- 减少重复代码
3. **性能优化**
- 避免值类
型的装箱拆箱操作
- 直接操作原始数据类
型
4. **集合安全性**
- 创建类
型安全的集合（如`List<T>`）
- 防止添加错误类
型元素
5. **算法通用化**
- 编写与数据类
型无关的通用算法
- 例如排序、搜索等算法
6. **约束灵活性**
- 通过约束指定类
型能力（如`where T : IComparable`）
- 平衡灵活性与安全性
---
###
泛型代码示例
#### 1. 基本
泛型类示例
```csharp
using System;
//
泛型类定义
public class Box<T>
{
private T content;
public Box(T initialContent)
{
content = initialContent;
}
public T GetContent()
{
return content;
}
public void UpdateContent(T newContent)
{
content = newContent;
}
}
class Program
{
static void Main()
{
// 整数盒子
Box<int> intBox = new Box<int>(42);
Console.WriteLine($"整数内容: {intBox.GetContent()}");
// 字符串盒子
Box<string> strBox = new Box<string>("Hello
Generics");
Console.WriteLine($"字符串内容: {strBox.GetContent()}");
// 自定义类
型盒子
Box<DateTime> dateBox = new Box<DateTime>(DateTime.Now);
Console.WriteLine($"日期内容: {dateBox.GetContent()}");
}
}
```
**解释**：
- `Box<T>`是
泛型类，`T`是类
型参数占位符
- 创建实例时指定具体类
型（如`Box<int>`）
- 同一
泛型类可安全处理不同类
型数据
#### 2.
泛型方法示例
```csharp
using System;
class
GenericMethods
{
//
泛型方法：交换两个值
public static void Swap<T>(ref T a, ref T b)
{
T temp = a;
a = b;
b = temp;
}
//
泛型方法：查找最大值（带约束）
public static T Max<T>(T a, T b) where T : IComparable<T>
{
return a.CompareTo(b) > 0 ? a : b;
}
}
class Program
{
static void Main()
{
// 交换整数
int x = 5, y = 10;
Console.WriteLine($"交换前: x={x}, y={y}");
GenericMethods.Swap(ref x, ref y);
Console.WriteLine($"交换后: x={x}, y={y}");
// 交换字符串
string s1 = "Hello", s2 = "World";
Console.WriteLine($"交换前: s1={s1}, s2={s2}");
GenericMethods.Swap(ref s1, ref s2);
Console.WriteLine($"交换后: s1={s1}, s2={s2}");
// 查找最大值
double maxDouble =
GenericMethods.Max(3.14, 2.71);
Console.WriteLine($"较大值: {maxDouble}");
string maxString =
GenericMethods.Max("Apple", "Banana");
Console.WriteLine($"字母顺序靠后: {maxString}");
}
}
```
**解释**：
- `Swap<T>`方法可交换任意类
型变量
- `Max<T>`方法使用约束`where T : IComparable<T>`确保类
型可比较
-
泛型方法可直接调用，编译器推断类
型
#### 3.
泛型约束示例
```csharp
using System;
public interface IIdentifiable
{
int Id { get; }
}
public class Product : IIdentifiable
{
public int Id { get; set; }
public string Name { get; set; }
}
public class Repository<T> where T : IIdentifiable
{
private List<T> items = new List<T>();
public void Add(T item)
{
items.Add(item);
}
public T GetById(int id)
{
return items.FirstOrDefault(i => i.Id == id);
}
}
class Program
{
static void Main()
{
Repository<Product> productRepo = new Repository<Product>();
productRepo.Add(new Product { Id = 1, Name = "Laptop" });
productRepo.Add(new Product { Id = 2, Name = "Phone" });
Product found = productRepo.GetById(2);
Console.WriteLine($"找到产品: {found?.Name}");
// 以下代码会编译错误，因为string不满足IIdentifiable约束
// Repository<string> invalidRepo = new Repository<string>();
}
}
```
**解释**：
- `where T : IIdentifiable`约束确保`T`实现指定接口
- 在`GetById`方法中可直接访问`Id`属性
- 尝试使用不满足约束的类
型会导致编译错误
---
###
泛型与Object的性能对比
```csharp
using System;
using System.Collections.
Generic;
using System.Diagnostics;
class PerformanceTest
{
const int Iterations = 10000000;
static void Test
GenericList()
{
List<int> list = new List<int>();
var sw = Stopwatch.StartNew();
for (int i = 0; i < Iterations; i++)
{
list.Add(i);
int value = list[0];
list.RemoveAt(0);
}
sw.Stop();
Console.WriteLine($"
泛型List耗时: {sw.ElapsedMilliseconds}ms");
}
static void TestArrayList()
{
ArrayList list = new ArrayList();
var sw = Stopwatch.StartNew();
for (int i = 0; i < Iterations; i++)
{
list.Add(i); // 装箱发生
int value = (int)list[0]; // 拆箱发生
list.RemoveAt(0);
}
sw.Stop();
Console.WriteLine($"ArrayList耗时: {sw.ElapsedMilliseconds}ms");
}
static void Main()
{
Test
GenericList();
TestArrayList();
}
}
```
**典
型输出**：
```
泛型List耗时: 520ms
ArrayList耗时: 2450ms
```
**性能差异解释**：
1. **装箱拆箱开销**：`ArrayList`存储`object`类
型，值类
型需要装箱（内存分配）和拆箱（类
型转换）
2. **类
型安全检查**：
泛型在编译时完成类
型检查，`ArrayList`需要运行时检查
3. **内存效率**：
泛型直接使用值类
型，避免额外内存分配
---
###
泛型使用最佳实践
1. **优先使用
泛型集合**：`List<T>`替代`ArrayList`
2. **合理使用约束**：平衡灵活性与安全性
3. **避免过度
泛化**：只在真正需要通用性的地方使用
4. **考虑协变逆变**：使用`in/out`关键字处理继承关系
5. **命名约定**：单字母类
型参数（T, K, V）或多字母描述性名称（TKey, TValue）
---
本文介绍了C#中的泛型机制，这是从C# 2.0开始引入的新特性，用于提高代码复用性和类型安全性。通过使用类型参数T，可以在不指定具体类型的情况下设计类和方法，直到客户端代码实例化时才确定具体类型，从而避免了装箱和拆箱带来的性能开销。
扫一扫
1450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
