简介：在C#编程中，集合与泛型集合是核心概念，关系到数据的存储和操作。集合如 ArrayList 和 HashTable 提供了灵活的数据管理，但存在类型安全问题。泛型集合如 List<T> 和 Dictionary<TKey, TValue> 则通过预定义类型 T 解决了这些问题，提高了性能和安全性。C#还提供了泛型接口如 IEnumerable<T> 和 IList<T> ，让开发者能够实现自定义的数据结构。掌握这些概念对于开发高效、健壮的C#程序至关重要。 
1. 集合在C#中的定义和应用
集合在C#中是一种包含一系列元素的数据结构，它使得我们能够将多个项存储为一个单元。这种结构在编程中非常重要，因为它们提供了一种方便的方式来组织和管理数据。根据集合中存储的数据类型，我们可以将C#中的集合分为两大类：非泛型集合和泛型集合。
1.1 集合的基础概念
在C#早期版本中，程序员主要使用 ArrayList 、 Hashtable 等非泛型集合。这些集合可以存储任何类型的对象，使得代码灵活但缺乏类型安全。非泛型集合在编译时不会检查类型，因此在运行时会出现类型转换错误。
ArrayList list = new ArrayList();
list.Add(1); // 添加整数
list.Add("Hello World"); // 添加字符串
// 运行时转换异常，因为ArrayList没有类型约束
int firstElement = (int)list[0];
在上述代码中，尽管我们将整数添加到了ArrayList，但编译器不会阻止我们将其作为字符串访问，导致运行时异常。
为了克服非泛型集合的这些缺点，C#引入了泛型集合。泛型集合提供类型安全，即编译时检查集合中的元素类型，减少运行时错误和类型转换需求。
1.2 泛型集合的引入
泛型集合的引入标志着.NET框架的进化，它允许我们在创建集合时指定集合元素的数据类型。这带来了极大的优势，包括编译时类型安全和性能优化。
List<int> intList = new List<int>();
intList.Add(1);
// intList.Add("Hello World"); // 编译错误，因为List<int>只接受整数
int firstElement = intList[0]; // 安全访问
在以上代码中，尝试添加一个字符串到 List<int> 会导致编译错误，从而提高了代码的安全性和可靠性。这就是泛型集合在C#中的定义和应用。后续章节将进一步探讨泛型集合的优势。
2. 泛型集合的定义和优势
2.1 泛型集合的基本概念
2.1.1 泛型的引入背景
泛型是在.NET框架1.1版本中引入的，主要是为了解决在使用集合时，由于类型转换而带来的性能开销和运行时异常。在引入泛型之前，开发者只能使用如ArrayList或Hashtable等非泛型集合类。这些集合类在设计上是将对象作为Object类型存储，因此在添加元素时会进行装箱操作，在检索元素时则需要拆箱操作。装箱和拆箱过程不仅增加了运行时的性能开销，还可能导致在运行时发生类型转换异常，即InvalidCastException。
2.1.2 泛型集合的定义及其结构
泛型集合是.NET框架在C#2.0及之后版本中引入的一种集合类型。泛型集合允许开发者在定义集合时指定集合元素的类型。通过这种方式，集合的元素类型在编译时就已经确定，从而避免了类型转换操作。泛型集合通常是在 System.Collections.Generic 命名空间中定义的，如List 、Dictionary 、Queue 等。 ,>
泛型集合的定义使用了类型参数 <T> 来表示集合可以存储的对象类型。这种类型参数在集合使用时必须被指定为一个具体类型。泛型集合的类型安全特性意味着它们只能存储指定类型的对象，从而减少了运行时的错误和性能损失。
2.2 泛型集合的优势分析
2.2.1 类型安全的提升
在泛型出现之前，非泛型集合由于类型擦除的问题，在使用时会产生类型转换，这导致在运行时可能出现类型不匹配的情况。泛型集合通过指定集合的元素类型，保证了类型安全，因为所有操作都局限于指定的类型之内。例如，创建一个泛型List 后，你无法将一个字符串添加到这个列表中，编译器会直接报错，从而避免了将来的运行时异常。
2.2.2 性能优化的原理
性能优化原理主要体现在两个方面：
-
减少装箱和拆箱操作 ：由于泛型集合知道它们存储的确切类型，因此不需要将值类型转换为object再存储，也不会在取回元素时从object转换回值类型，从而消除了装箱和拆箱操作。
-
更高效的代码生成 ：泛型代码允许编译器对代码进行更好的优化，因为它知道确切的类型信息。在运行时，不需要进行额外的类型检查和转换，因为类型信息已经内置在编译后的代码中。
2.2.3 与非泛型集合的对比
对比泛型集合和非泛型集合，我们可以从类型安全和性能两个主要方面来展开。首先，在类型安全方面，泛型集合通过编译时检查提供更强的类型保障，而非泛型集合则存在运行时类型转换的隐患。在性能方面，泛型集合避免了装箱/拆箱操作，并且编译后的代码更加高效，而非泛型集合在存储值类型数据时会有明显的性能损失。
让我们通过一个简单的代码示例，来展示泛型集合如何在代码中使用，并体现其类型安全和性能优势：
using System;
using System.Collections.Generic;
class Program
{
static void Main(string[] args)
{
// 使用泛型集合
List<int> genericList = new List<int>();
genericList.Add(10);
genericList.Add(20);
// 尝试错误类型
// genericList.Add("A string"); // 编译错误，无法添加非int类型的元素
// 迭代泛型集合
foreach (int item in genericList)
{
Console.WriteLine(item);
}
// 非泛型集合的使用和性能问题
ArrayList nonGenericList = new ArrayList();
nonGenericList.Add(10);
nonGenericList.Add("A string"); // 这里会发生装箱操作
// 迭代非泛型集合
foreach (object item in nonGenericList)
{
// 进行拆箱操作
int value = (int)item;
Console.WriteLine(value);
}
}
}
在此示例中，我们首先创建了一个泛型List 并尝试添加非int类型元素，编译器报错，阻止了潜在的类型不匹配问题。迭代时直接返回int类型，无需类型转换。对于ArrayList的使用，由于是非泛型集合，我们能够添加任何类型的元素，但在迭代时需要拆箱操作，并且因为装箱和拆箱操作会带来额外的性能开销。通过这种方式，泛型集合的优势得以在代码中明显体现。
3. 类型安全的概念
类型安全是编程语言和软件开发中一个核心概念，它确保变量在使用之前已经被赋予正确的类型，并在整个程序运行期间保持该类型。理解类型安全的重要性对于开发高效、可靠的应用程序至关重要。
3.1 类型安全的重要性
3.1.1 类型安全与数据完整性的关系
类型安全直接关系到数据的完整性。数据完整性是指数据在存储、处理过程中，保持准确、一致和可信的特性。在类型安全的系统中，数据的类型在编译时就已经确定，并且在整个程序执行期间不会发生改变。这样可以有效地防止数据类型错误，避免诸如将字符串错误地当作整数处理的情况发生，这将大幅减少bug的发生，提升系统的稳定性和可靠性。
3.1.2 类型安全对编程语言的影响
不同类型的语言对类型安全的处理方式不同。静态类型语言（如C#、Java）在编译时就进行类型检查，而动态类型语言（如Python、JavaScript）则在运行时进行。静态类型语言因其类型安全的优势，可以提前发现类型错误，有助于减少程序运行时的错误，使得代码更易于维护和重构。然而，这也带来了一定的限制，因为它减少了语言的灵活性。
3.2 类型安全在泛型中的应用
3.2.1 泛型在保障类型安全中的作用
泛型是现代编程语言中用于增加类型安全性的强大工具。在C#中，泛型集合如 List<T> 和 Dictionary<TKey, TValue> 允许开发者定义集合元素的类型，这个类型在集合创建时确定，并在使用时强制执行。这极大地提升了集合操作的类型安全性，因为集合中的元素在编译时就被限制为特定类型，编译器可以进行类型检查，从而避免类型转换错误和运行时类型检查的开销。
3.2.2 类型推断与类型检查
C#支持类型推断，这意味着在定义和实例化泛型集合时，可以不必显式指定类型参数。编译器能够根据上下文自动推断出正确的类型。这一特性不仅简化了代码，还保持了类型安全。在C#中，即使使用类型推断，也会在编译时进行隐式类型检查，以确保类型安全。
// 类型推断示例
var myIntList = new List<int> { 1, 2, 3 };
// 显式类型检查
List<int> anotherIntList = new List<int>();
anotherIntList.Add(4);
// 试图添加非int类型将导致编译错误
// anotherIntList.Add("This won't work.");
在上述代码块中，第一行使用了隐式类型推断来创建一个 List<int> 集合。第二行尝试向该列表中添加一个整数。如果尝试添加一个非整数类型的对象，如字符串，则会导致编译错误，这展示了泛型集合如何强制执行类型安全。
3.2.3 类型安全的其他实现方式
除了泛型外，现代编程语言还采用了其他一些技术来实现类型安全，例如：
- 枚举类型 ：限制变量只能是预定义的一组值中的一个。
- 结构体 ：类似于类，但通常用于存储轻量级的数据结构。
- 命名空间和模块 ：组织代码，限制变量和函数的作用域。
下面的表格列举了这些方式的使用示例：
| 类型安全技术 | 描述 | 示例 | | ------------ | ---- | ---- | | 泛型 | 提供类型参数的集合和方法 | List<T> 、 Dictionary<TKey, TValue> | | 枚举类型 | 限制变量为一组预定义值之一 | enum Color { Red, Green, Blue } | | 结构体 | 数据组织方式，保证数据的完整性 | struct Point { int X; int Y; } | | 命名空间 | 组织代码，限制变量和函数的作用域 | namespace MyNamespace |
通过在编程实践中应用这些技术，开发者可以构建更为安全、健壮的系统。而在下一章中，我们将深入探讨性能优化的具体体现，以及泛型如何在此过程中发挥作用。
4. 性能提升的具体体现
性能提升是软件开发中一个永恒的话题，特别是在处理大量数据和需要高效算法的应用中。在C#中，泛型集合的使用是优化性能的关键技术之一，这归功于其在类型安全和运行时效率方面的优势。本章将深入探讨性能优化的理论基础，并展示泛型集合如何具体实现性能提升。
4.1 性能优化的理论基础
在软件开发中，性能优化是提高软件效率和响应速度的关键环节。要进行有效的性能优化，我们首先需要理解性能评估的基本指标和优化的一些一般原则。
4.1.1 程序性能的评估指标
性能评估通常涉及以下几个核心指标：
- 执行时间 ：程序运行所需的总时间，是衡量性能最直观的指标。
- 内存使用 ：程序在执行过程中占用的内存大小。
- CPU 使用率 ：程序在运行期间对CPU资源的占用比例。
- I/O 操作 ：程序对输入/输出设备的访问频率和数据量，特别是对磁盘和网络的访问。
理解这些指标对于后续的性能优化至关重要，因为优化工作往往就是针对这些指标来进行的。
4.1.2 性能优化的一般原则
性能优化不是随意进行的，它需要遵循一些基本原则：
- 不要优化尚未确定的代码 ：优化应该基于性能测试结果，针对瓶颈进行。
- 优化前先进行分析 ：了解瓶颈和性能问题的根本原因。
- 以小步快跑的方式优化 ：逐步实现，每步优化后都要进行性能测试。
- 保持代码的可读性和可维护性 ：优化不应牺牲代码的质量。
接下来，我们将探讨泛型集合如何在实际应用中提升性能。
4.2 泛型集合的性能优势
泛型集合相比非泛型集合在性能上有明显的优势。这些优势主要来自于类型安全带来的效率提升和编译时类型检查。
4.2.1 运行时类型检查的减少
泛型集合允许在编译时进行类型检查，这意味着在运行时，程序不必再进行繁琐的类型检查。举一个简单的例子：
假设我们有一个 List 类型的集合，非泛型版本的 List 在添加元素时，需要在运行时检查元素类型是否正确，增加了额外的性能开销。而在泛型版本的 List<T> 中，这样的检查在编译时就已经完成，因此在运行时不需要重复进行，提高了效率。
List nonGenericList = new List(); // 非泛型集合
nonGenericList.Add("Some string"); // 运行时类型检查
List<int> genericList = new List<int>(); // 泛型集合
genericList.Add(10); // 编译时类型检查，运行时无额外开销
4.2.2 盒装与拆装操作的优化
在.NET框架中，值类型和引用类型处理上有一个显著的区别。值类型在被添加到非泛型集合（如 ArrayList ）时，会发生隐式的装箱（Boxing）操作。装箱是指将值类型转换为 object 类型，并在堆上分配内存。当从非泛型集合中移除元素时，则会发生拆装（Unboxing）操作。这两种操作都会消耗额外的性能。
而泛型集合由于在编译时就知道了具体的数据类型，因此避免了不必要的装箱和拆装操作，进一步提高了性能。
ArrayList arrayList = new ArrayList();
arrayList.Add(10); // int 类型被装箱为 object
List<int> genericList = new List<int>();
genericList.Add(10); // 不会发生装箱，因为集合中存储的类型已知为 int
以上代码段展示了使用 ArrayList 和 List<int> 的差异。可以看出，通过使用泛型集合，我们有效地减少了不必要的内存分配和回收，从而达到性能提升的目的。
结构对比
这里我们通过一个表格，更直观地比较非泛型集合与泛型集合在性能方面的差异：
| 性能因素 | 非泛型集合 | 泛型集合 | |----------|-------------|-----------| | 类型检查 | 运行时 | 编译时 | | 装箱操作 | 发生 | 不发生 | | 代码清晰度 | 类型不明确，需频繁类型转换 | 类型明确，无需类型转换 | | 性能开销 | 较高 | 较低 |
在性能要求较高的应用中，选择合适的集合类型，可以有效提升应用的响应速度和吞吐量。泛型集合由于其类型安全和性能优势，成为了开发者在集合选择上的首选。
5. 泛型接口和类的基本规范
5.1 泛型接口的设计原则
5.1.1 接口与泛型的结合
在C#中，接口是定义一组方法规范的引用类型。通过将接口与泛型结合，可以创建出适用于不同数据类型而又保持相同行为的接口。泛型接口的引入，使得代码更加灵活和可重用，同时避免了因类型转换而带来的性能开销。
泛型接口的一个基本例子是 IEnumerable<T> ，它表示一系列可枚举的元素，并且支持元素的遍历。 T 代表元素的数据类型，允许实现该接口的任何类型来定义元素的实际类型。
public interface IEnumerable<T>
{
IEnumerator<T> GetEnumerator();
}
在这个接口定义中， T 是一个占位符，表示该接口可以操作的数据类型。这种设计允许 List<T> 或 Dictionary<TKey, TValue> 这样的泛型集合类实现 IEnumerable<T> 接口。
5.1.2 常见泛型接口及其用途
泛型接口在.NET框架中有广泛的应用，下面列举了一些常见的泛型接口及其用途：
-
IEnumerable<T>：表示可以通过迭代器访问元素的集合。 -
ICollection<T>：继承自IEnumerable<T>，增加了集合大小的属性和添加、移除元素的方法。 -
IList<T>：继承自ICollection<T>，表示一个可以随机访问其元素的有序集合。 -
IDictionary<TKey, TValue>：表示键值对的集合，其中键是唯一的。
public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
{
TValue this[TKey key] { get; set; }
ICollection<TKey> Keys { get; }
ICollection<TValue> Values { get; }
}
在上面的代码块中， IDictionary<TKey, TValue> 接口定义了基本的字典操作，包括键值对的访问和修改。
泛型接口的设计允许开发者在不知道具体实现的情况下，编写能够处理多种类型集合的通用代码。这一点在创建需要处理多种数据类型的通用框架和库时特别有用。
5.2 泛型类的特点和构造
5.2.1 泛型类的定义和实例化
泛型类是一种使用一个或多个类型参数的类。在定义泛型类时，类型参数被放在类名后面的尖括号中。这允许在类的定义中使用类型参数作为方法的返回类型、字段和局部变量的类型。
泛型类的一个例子是 List<T> ，它提供了一个动态数组的功能。
public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
{
// 类的实现细节
}
在上面的代码中， List<T> 是一个泛型类，其构造与实例化通常如下：
List<int> intList = new List<int>();
List<string> stringList = new List<string>();
泛型类的实例化涉及到指定类型参数（如 int 或 string ），以便编译器能够提供适当的类型检查，并在运行时使用正确的类型。
5.2.2 泛型类的继承和多态
泛型类同样支持继承和多态性，这意味着一个泛型类可以派生自另一个泛型类或接口，同时也可以被其他类继承。泛型类的继承遵循与非泛型类相同的规则。
泛型类的多态性通过其类型参数的替换来实现。子类可以具有与父类不同的类型参数，或者如果需要，可以为相同的类型参数。
public class MyGenericClass<T> : BaseGenericClass<T> where T : IComparable
{
// 类的具体实现
}
在上面的代码中， MyGenericClass<T> 是从另一个泛型类 BaseGenericClass<T> 继承而来，并且通过约束 where T : IComparable 对 T 施加了额外的条件，确保了类型参数 T 具有可比较性。
继承和多态性为泛型类提供了灵活性和可扩展性，允许开发者根据需要定制和扩展泛型集合的功能。
通过本章节的介绍，我们可以了解到泛型接口和类的基本规范，以及它们在实现类型安全和性能优化方面的重要性。在后续章节中，我们将深入探讨泛型集合类的具体应用，并通过实例加深理解。
6. System.Collections 命名空间中的集合类
6.1 System.Collections 概述
6.1.1 命名空间的历史和组成
System.Collections 命名空间在.NET框架早期版本中就已经存在，提供了非泛型集合类的支持。这些类被设计为可以存储任何类型的对象，它们大多基于 System.Object ，因此在使用时常常需要进行显式类型转换，这在一定程度上牺牲了类型安全。
命名空间中的主要非泛型集合类包括：
-
ArrayList：一个可以动态增长的数组，支持任何类型的对象。 -
Hashtable：一个基于键值对的集合，使用哈希表实现。 -
Queue：用于先进先出(FIFO)场景的集合。 -
Stack：用于后进先出(LIFO)场景的集合。 -
BitArray：操作一组布尔值的集合。
这些类的设计考虑到了操作的简便性，但随着软件开发的演进，它们的局限性逐渐显现。特别是对于大型应用程序，类型安全和性能成为关注的焦点，这促使了泛型集合的出现。
6.1.2 非泛型集合类的使用场景
尽管泛型集合在很多方面都优于非泛型集合，但在一些特定的场景下，非泛型集合类仍然有其适用之处。例如，在需要向后兼容旧代码或库时，非泛型集合可以简化升级过程。此外，对于一些小型项目或性能要求不是特别高的场景，使用非泛型集合类可能更简单方便。
在实际开发中，开发者应该根据项目需求和上下文环境来选择合适的集合类型。使用非泛型集合时，务必谨慎处理类型转换，以避免运行时异常和数据不一致的问题。
6.2 具体非泛型集合类分析
6.2.1 ArrayList 和 Hashtable 的使用
ArrayList 是一个动态数组，可以存储任意类型的对象，当向 ArrayList 中添加元素时，它会自动扩展容量以适应新元素。然而，这种灵活性是以牺牲类型安全为代价的。例如，下面的代码展示了如何使用 ArrayList ：
ArrayList list = new ArrayList();
list.Add("Hello");
list.Add(123);
foreach (var item in list)
{
Console.WriteLine(item.ToString());
}
在上述代码中，我们向 ArrayList 中添加了一个字符串和一个整数，遍历时需要将每个元素显式转换为 string 才能进行处理。如果转换失败，程序将在运行时抛出异常。
Hashtable 则是一个基于键值对的集合，其内部使用哈希表来实现快速查找。不过，由于其存储的元素为 DictionaryEntry 结构体，也会带来类型安全的问题：
Hashtable table = new Hashtable();
table["key1"] = "value1";
table["key2"] = 123;
foreach (DictionaryEntry entry in table)
{
Console.WriteLine($"Key: {entry.Key}, Value: {entry.Value}");
}
在上述代码中，尽管我们知道每个键对应的值应该是字符串类型，但是由于 Hashtable 的泛型类型限制，我们在获取值时无法保证类型安全。
6.2.2 非泛型集合的性能考量
非泛型集合的一个主要问题是它们在运行时需要进行大量的类型检查和转换，这会增加性能开销。例如，对于 ArrayList 和 Hashtable ，每次添加或访问元素时，都需要进行装箱和拆箱操作，特别是在处理值类型数据时。
装箱操作是将值类型转换为 Object 类型的过程，而拆箱则是相反的过程。这两个操作都会消耗CPU资源，影响程序性能。例如，在 ArrayList 中添加一个整数：
ArrayList list = new ArrayList();
int number = 123;
list.Add(number); // 装箱操作
如果在循环中反复执行上述操作，性能损失将变得非常可观。同样，当从 ArrayList 中检索一个整数时，也需要拆箱操作，这同样会消耗性能。
因此，在处理大量数据或性能敏感的应用时，开发者应该考虑使用泛型集合，如 List<T> 或 Dictionary<TKey, TValue> ，这些集合在编译时就能保证类型安全，并减少不必要的装箱和拆箱操作，从而提高整体性能。
6.3 总结
在本章中，我们介绍了 System.Collections 命名空间中的非泛型集合类的历史和组成，分析了 ArrayList 和 Hashtable 的使用方法，并讨论了非泛型集合在实际应用中可能带来的类型安全和性能问题。通过实例代码和性能考量，我们看到非泛型集合虽然有其使用场景，但在多数情况下，选择泛型集合将更加安全和高效。
接下来的章节我们将探讨 System.Collections.Generic 命名空间中的泛型集合类，这些集合类在类型安全和性能上都对 System.Collections 进行了显著的改进，并提供了更加现代化的集合操作支持。
7. System.Collections.Generic 命名空间中的泛型集合类
在C#中，泛型集合类的引入是为了满足强类型数据操作的需求，同时带来更好的性能和类型安全。在本章中，我们将深入了解 System.Collections.Generic 命名空间中的泛型集合类，学习它们的组成、特点和在实际开发中的深入应用。
7.1 System.Collections.Generic 的组成和特点
System.Collections.Generic 命名空间下包含了多种泛型集合类，如 List<T> , Dictionary<TKey,TValue> , Queue<T> , Stack<T> 等。这些集合类都遵循统一的泛型类型参数，以实现类型安全和性能优化。
7.1.1 泛型集合类的分类
System.Collections.Generic 命名空间中的泛型集合类可以按照其用途进行分类：
- 列表类（List）
-
List<T>：动态数组，支持元素的快速访问和随机插入删除。 - 字典类（Dictionary）
-
Dictionary<TKey,TValue>：键值对集合，通过键快速访问值。 - 栈和队列类（Stack & Queue）
-
Stack<T>：后进先出（LIFO）的数据结构。 -
Queue<T>：先进先出（FIFO）的数据结构。 - 集合类（Set）
-
HashSet<T>：不允许重复元素的集合。 - 只读集合
-
ReadOnlyCollection<T>：提供了集合的只读视图。
7.1.2 泛型集合的运行时性能优势
泛型集合在运行时由于减少了类型转换和装箱/拆箱操作，从而显著提升了性能。具体表现在：
- 运行时类型信息的减少：泛型集合在编译时就确定了集合中元素的类型，运行时不需要进行类型转换。
- 装箱和拆箱的减少：泛型集合中的元素直接使用引用类型或值类型，无需装箱到Object类型，避免了拆箱时的性能开销。
7.2 泛型集合类的深入应用
泛型集合类在复杂的数据结构和算法实现中发挥着重要作用。它们不仅提供了基础的数据存储功能，还支持迭代器模式，使得集合的遍历更加方便和高效。
7.2.1 Dictionary<TKey,TValue> 等高级泛型集合的使用
Dictionary<TKey,TValue> 是一个用于存储键值对的集合，它是基于哈希表实现的。以下是如何创建并使用 Dictionary 的一个示例：
using System;
using System.Collections.Generic;
public class Program
{
public static void Main()
{
// 创建一个Dictionary实例
Dictionary<string, int> ages = new Dictionary<string, int>();
// 添加一些键值对
ages.Add("John", 28);
ages.Add("Jane", 26);
// 尝试添加已存在的键
// 错误使用示例: ages.Add("John", 29); // 将引发异常
// 检查是否存在某个键
if (ages.ContainsKey("John"))
{
Console.WriteLine($"John's age is {ages["John"]}.");
}
// 遍历Dictionary
foreach (KeyValuePair<string, int> pair in ages)
{
Console.WriteLine($"{pair.Key} is {pair.Value} years old.");
}
}
}
7.2.2 集合的迭代器和延迟执行
迭代器（Iterator）允许以一种简单的方式对集合进行遍历。在泛型集合中，迭代器通常是通过 foreach 语句来实现的。迭代器的使用可以提高集合操作的灵活性和效率。以下是一个使用迭代器的简单示例：
using System;
using System.Collections.Generic;
public class Fibonacci : IEnumerable<int>
{
private int count;
public Fibonacci(int count)
{
this.count = count;
}
public IEnumerator<int> GetEnumerator()
{
int previous = 0, current = 1;
for (int i = 0; i < count; i++)
{
yield return previous;
int next = previous + current;
previous = current;
current = next;
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
public class Program
{
public static void Main()
{
// 创建一个Fibonacci迭代器实例
Fibonacci fib = new Fibonacci(10);
// 遍历并打印前10个斐波那契数
foreach (int number in fib)
{
Console.Write(number + " ");
}
}
}
在这个例子中， Fibonacci 类实现了 IEnumerable<int> 接口，通过 yield return 语句定义了斐波那契数列的迭代逻辑。这种实现方式称为懒惰求值（Lazy Evaluation），即元素只有在被迭代器访问到时才进行计算。
以上章节详细介绍了 System.Collections.Generic 命名空间中的泛型集合类的组成、特点以及深入应用。泛型集合类不仅提供了类型安全和运行时性能优势，还通过迭代器模式提供了强大的数据操作能力。这些集合类成为了.NET框架中不可分割的一部分，广泛应用于各类业务逻辑的实现中。
简介：在C#编程中，集合与泛型集合是核心概念，关系到数据的存储和操作。集合如 ArrayList 和 HashTable 提供了灵活的数据管理，但存在类型安全问题。泛型集合如 List<T> 和 Dictionary<TKey, TValue> 则通过预定义类型 T 解决了这些问题，提高了性能和安全性。C#还提供了泛型接口如 IEnumerable<T> 和 IList<T> ，让开发者能够实现自定义的数据结构。掌握这些概念对于开发高效、健壮的C#程序至关重要。