C#集合-列举（Enumeration）

2024-08-22 14:48
文章标签 c# .net 集合 netcore 列举 enumeration

本文主要是介绍C#集合-列举（Enumeration），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

在计算机这个范畴内存在许多种类的集合，从简单的数据结构比如数组、链表，到复杂的数据结构比如红黑树，哈希表。尽管这些数据结构的内部实现和外部特征大相径庭，但是遍历集合的内容确是一个共同的需求。.NET Framework通过IEnumerable和IEnumerator接口实现遍历集合功能。

Non-GenericGeneric备注
IEnumeratorIEnumerator<T> 
IEnumerableIEnumerable<T>仅可遍历
ICollectionICollection<T>遍历，可统计集合元素
IDictionary
IList		IDictionary<TKey,TValue>
IList<T>		拥有更过的功能

 

IEnumerable与IEnumerator

IEnumerator接口定义了遍历协议--在这个协议中，集合中的元素使用向前的方式进行遍历。它的声明如下：

复制代码

public interface IEnumerator
{   bool MoveNext();Object Current { get; }void Reset();
}

复制代码

MoveNext将当前元素或指针移动到下一个位置，如果下一个位置没有元素那么返回false。Current返回在当前值位置的元素。在获取集合的第一个元素之前，必须调用MoveNext方法--这对于空集合同样适用。Reset方法，这移动到初始位置，从而允许集合可以再次遍历。Reset更过多是为COM互操作而设计：应该尽量直接避免调用此方法，因为它并没有得到普遍的支持（直接调用此方法是不必要的，因为创建一个新的列举实例更容易）。

集合一般都不实现列举器，相反，它们通过IEnurable接口提供列举器

public interface IEnumerable
{   IEnumerator GetEnumerator();
}

通过定义一个单一返回列举器的方法，IEnumerable接口提供了更多的灵活性，从而各个实现类的遍历集合的逻辑可以各部相同。这也就意味着每个集合的使用者都可以创建自己的方法遍历集合而不会相互影响。IEnumerable可以被视作IEnumeratorProvider，它是所有集合类都必须实现的一个接口。

下面的代码演示了如何使用IEnumerable和IEnumerator：

复制代码

string s = "Hello";// IEnumerator
IEnumerator rator = s.GetEnumerator();
while (rator.MoveNext())Console.Write(rator.Current + ".");Console.WriteLine();// IEnumerable
foreach (char c in s)Console.Write(c + ".");

复制代码

 

一般地，很少调用GetEnumerator方法得到IEnumerator接口，这是由于C#提供了foreach语法(foreach语法编译后，会自动调用GetEnumerator从而遍历集合)，这使得代码变得更简洁。

 

IEnumerable<T>与IEnumerator<T>

IEnumerator和IEnumerable对应的Generic接口定义如下：

复制代码

public interface IEnumerator<out T> : IDisposable, IEnumerator
{    new T Current {get; }
}public interface IEnumerable<out T> : IEnumerable
{ new IEnumerator<T> GetEnumerator();
}

复制代码

Generic的Current和GetEnumerator，增加了接口IEnumerable<T>与IEnumerator<T>的类型安全性，避免了对值类型进行装箱操作，对于集合的使用者更加便利。请注意，数字类型默认实现了IEnumerable<T>接口。

正是由于实现了类型安全的接口，方法Test2(arr)在编译时就会报错：

复制代码

static void Main(string[] args)
{char[] arr = new char[] { '1', '2', '3' };Test1(arr);  // okTest2(arr); // complie-error: cannot convert from char[] to IEnumerable[]
Console.ReadLine();
}static void Test1(IEnumerable numbers)
{foreach (object i in numbers)Console.Write(i + ",");
}static void Test2(IEnumerable<int> numbers)
{foreach (object i in numbers)Console.Write(i + ",");
}

复制代码

请注意，Array默认实现了IEnumerable<T>接口，那么它同时必然实现了IEnumerable接口。虽然char[]不能转换成IEnumrable<int>，但是却可以转换成IEnumeable,所以Test1可以通过编译，而Test2不能通过编译（类型转化失败错误）

对于集合类，对外暴露IEnumerable<T>是标准做法；并需要显示地实现IEnumerable接口，从而隐藏非Generic的IEnumerable。此时，你再调用GetEnumerator，将得到IEnumerator<T>。但有时候，为了兼容非Generic的集合，我们可以不遵守这个规则。最好的例子就是数组集合，数组必须返回非generic的IEnumerator以避免与早期的代码冲突。在这种情况下，为了获取IEnumerator<T>,就必须先把数组显示地转化为Generic接口，然后再获取：

char[] arr = new char[] { '1', '2', '3' };
var rator = ((IEnumerable<char>)arr).GetEnumerator();

幸运的是，你很少需要编写这样的代码，这就要归功于foreach语句。

 

IEnumerable<T>和IDisposable

IEnumerator<T>继承了IDisposable。这就允许列举器可以拥有资源的引用比如数据库连接，从而确保在遍历完成后释放这些资源。foreach会语句会识别这个特性，比如，下面的foreach语句

IList<char> chars =new List<char>(){'a', 'b', 'c'};foreach (char c in chars)Console.Write(c);

编译后的代码为：

复制代码

.method private hidebysig static void  Main(string[] args) cil managed
{......IL_0026:  callvirt   instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> class [mscorlib]System.Collections.Generic.IEnumerable`1<char>::GetEnumerator()IL_002b:  stloc.3.try{.......
System.Collections.Generic.IEnumerator`1<char>::get_Current()......IL_0036:  call       void [mscorlib]System.Console::Write(char)......IL_003d:  callvirt   instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()......}  // end .try
  finally{......IL_0055:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()......}  // end handler
  ......
} // end of method Program::Main

复制代码

因此，如果实现了IEnumable<T>接口，执行foreach时，会转化成调用GetEnumerator<T>, 在遍历完成之后，释放IEnumerator<T>。

 

实现列举接口

当满足下面的一个或多个条件时，需要实现IEnumerable或IEnumerable<T>

  1. 为了支持foreach语句
  2. 为了实现除了标准集合之外的集合都是可互操作的
  3. 为了满足一个复杂集合接口
  4. 为了支持集合初始化

而实现IEnumerable/IEnumerable<T>，你必须提供一个列举器，你可以通过下面三种方式实现

 

 

 

 

 

 

 

  • 如果类包含了另外集合，那么需要返回所包含集合的列举器
  • 在迭遍历内部使用yield return
  • 实例化IEnumerator/IEnumerator<T>的实现

1）实例IEnumerator/IEnumerator<T>

返回另外一个集合的列举器就是调用内部集合的GetEnumerator。但是，这只发生在简单的场景中，在这样的场景中，内部集合中的元素已经满足需要。另外一种更为灵活的方式是通过yield return语句生成一个迭代器。迭代器(iteraotr)是C#语言特性，该特性用于辅助生产集合，同样地foreach可与用于iterator以遍历集合。一个迭代器自动处理IEnumerable和IEnumerator的实现。下面是一个简单的例子

复制代码

internal class MyCollection : IEnumerable
{int[] data ={ 1, 2, 3 };public IEnumerator GetEnumerator(){foreach (int i in data)yield return i;}
}

复制代码

请注意，GetEnumerator根本就没有返回一个列举器。依赖于解析yield return后的语句，编译器编写了一个隐藏的内嵌列举器类，然后重构  GetEnumerator实现实例化，最后返回该类。迭代不仅功能强大而且简单。

通过IL代码，我们可以看到确实生产了一个内嵌的列举器类

image 

 

我们在上面代码的基础上，对MyCollecton做些许修改，使其不仅仅实现IEnumerable，还实现IEnumerable<T>

复制代码

internal class MyCollection : IEnumerable<int>
{int[] data ={ 1, 2, 3 };        public IEnumerator<int> GetEnumerator(){foreach (int i in data)yield return i;}IEnumerator IEnumerable.GetEnumerator(){return GetEnumerator();}
}

复制代码

因为IEnumerable<T>继承了IEnumerable，因此我们必须实现generic的GetEnumerator和非generic的GetEnumerator。按照标准的做法，我们已经实现了Generic的GetEnumerator。因此对于非Generic的GetEnumerator，我们直接调用Generic的GetEnumerator即可，这是因为IEnumerable<T>继承了IEnumerbale。

对应的IL代码如下：（请注意编译器实现的IEnumerator<Int32>接口，而不再是IEnumerator<Object>接口）

image

2）在使用yield return返回IEnumerable<T>

我们创建的类MyCollection可以做为复杂集合类的基本实现。但是，如果你不需要实现IEnumerable<T>，那么应可以通过yield return语句实现一个IEnumerable<T>，而不是编写MyCollection这样的类。也就是说你可以把迭代逻辑迁移到一个返回IEnumerable<T>的方法中，然后让编译器来为你完成剩余的事情。

复制代码

class Program
{static void Main(string[] args){foreach(int i in GetSomeIntegers())Console.WriteLine(i);Console.ReadLine();}static IEnumerable<int> GetSomeIntegers(){int[] data = { 1, 2, 3 }; foreach (int i in data)yield return i;}       
}

复制代码

与之对应的IL代码

image

从IL代码中，我们可以看到，编译器同样生产了一个内部的类，该类实现了IEnumerator<Int32>接口。

3）如果类包含了另外集合，那么需要返回所包含集合的列举器

最后一种实现方式将就是编写一个类直接实现IEnumerator接口。其实这也就是编译器之前做的事情。在实际中，你不需要这么做。

首先我们来实现非Generic的IEnumerator

复制代码

internal class MyCollection : IEnumerable
{int[] data ={ 1, 2, 3 };        public IEnumerator GetEnumerator(){return new Enumerator(this);}private class Enumerator : IEnumerator{MyCollection collection;int index;public Enumerator(MyCollection collection){this.collection = collection;index = -1;}public object Current{get { return collection.data[index]; }}public bool MoveNext(){if (index < collection.data.Length-1){index++;return true;}return false;}public void Reset(){index = -1;}}
}

复制代码

然后，我们在上述代码的基础上，实现Generic的IEnumerator

复制代码

internal class MyCollection : IEnumerable<Int32>
{int[] data = { 1, 2, 3 };// implement IEnumerable<T>public IEnumerator<Int32> GetEnumerator(){return new Enumerator(this);}// implement IEnumerable
    IEnumerator IEnumerable.GetEnumerator(){return GetEnumerator();}private class Enumerator : IEnumerator<Int32>{MyCollection collection;int index;public Enumerator(MyCollection collection){this.collection = collection;index = -1;}#region implement IEnumerator<T>public int Current{get { return collection.data[index]; }}public void Dispose(){}            public bool MoveNext(){if (index < collection.data.Length - 1){index++;return true;}return false;}public void Reset(){index = -1;}#endregion// implement IEnumeratorobject IEnumerator.Current{get { return Current; }}}
}

复制代码

Generic版本的IEnumerator比非Generic的IEnumberator效率高一些，因为不需要把int转化成object，从而减少了装箱的开销。我们多看一眼此时对应的IL代码：

image

显然地，我们可以看到我们手动创建Enumerator与编译器生成的Enumerator是一样的

 

此外，当我们使用第二种方式的时候，如果我们有多个IEnumerable<T>的方法，那么编译器会产生多个实现了IEnumerator<T>的类

复制代码

class Program
{static void Main(string[] args){foreach (int i in GetSomeIntegers())Console.WriteLine(i);foreach (int i in GetSomeOdds())Console.WriteLine(i);Console.ReadLine();}static IEnumerable<Int32> GetSomeIntegers(){int[] collection = { 1, 2, 3, 4, 5 };foreach (int i in collection)yield return i;}static IEnumerable<Int32> GetSomeOdds(){int[] collection = { 1, 2, 3, 4, 5 };foreach (int i in collection)if(i%2==1)yield return i;}       }

复制代码

对应的IL代码可以看到有两个内部IEnumerator<T>类

image

 

而下面的代码只会产生一个IEnumerator<T>类

复制代码

class Program
{static void Main(string[] args){foreach (int i in GetSomeIntegers())Console.WriteLine(i);foreach (int i in GetSomeOdds())Console.WriteLine(i);Console.ReadLine();}static IEnumerable<Int32> GetSomeIntegers(){return GetDetails();}static IEnumerable<Int32> GetSomeOdds(){return GetDetails(true);}private static IEnumerable<Int32> GetDetails(bool isOdd = false){int[] collection = { 1, 2, 3, 4, 5 };int index = 0;foreach (int i in collection){if (isOdd && i % 2 == 1)yield return i;if (!isOdd)yield return collection[index];index++;}}   
}

复制代码

同样地，下面的代码也只会产生一个IEnumerator<T>类

复制代码

....
static IEnumerable<Int32> GetSomeIntegers()
{foreach (int i in GetDetails())yield return i;
}static IEnumerable<Int32> GetSomeOdds()
{foreach (int i in GetDetails(true))yield return i;
}
....

复制代码

 

由此，我们可以发现，在实现IEnumerable时，特别是有多个实现时，需要注意尽量减少编译器生成IEnumerator的类的个数。我猜测在内部，编译器应该是根据真正不同的yield return对于的iterator来确定IEnumerator类的个数。在我的示例代码中，产出两个IEnumerator类时，GetSomeIntegers和GetSomeOdds的yield return的iterator是不同的；而在产生一个IEnumerator类时，它们都指向GetDetails的yield return对应的iterator。

 

最后，我们再来看看IEnumerator与Iterator

在网上，并没有关于两者的明确区分，或许是我把两个不该混淆的概念混淆了。下面是我自己的看法，如果不正确，欢迎指正：

1） 实现IEnumerator用于实现IEnumerable，与GetEnumerator方法关联在一起，从而可以使用foreach；而且一旦一个类中确定了遍历（MoveNext）的方式之后，那么就只有这一种方式去遍历集合了。.NET Framework中大多数集合的IEnumerator都默认向前只读的方式遍历集合。

2）Iterator用于遍历集合，可以有多个实现方式，唯一的要求是返回IEnumerator<T>，从某种意义上说，Iterator就是IEnumerator。两者的区别是，前者一旦确定，就只能使用这个方式遍历集合然后返回一个IEnumerator；而后者可以在多个方法中以多种方式遍历集合然后返回不同的IEnumerator。（我认为，两者的差别与IComparable和IComparer的差别类似）。

这篇关于C#集合-列举（Enumeration）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1096578。

相关文章

C#实现文件读写到SQLite数据库

C#实现文件读写到SQLite数据库

《C#实现文件读写到SQLite数据库》这篇文章主要为大家详细介绍了使用C#将文件读写到SQLite数据库的几种方法,文中的示例代码讲解详细,感兴趣的小伙伴可以参考一下... 目录1. 使用 BLOB 存储文件2. 存储文件路径3. 分块存储文件《文件读写到SQLite数据库China编程的方法》博客中，介绍了文
阅读更多...
使用C#如何创建人名或其他物体随机分组

使用C#如何创建人名或其他物体随机分组

《使用C#如何创建人名或其他物体随机分组》文章描述了一个随机分配人员到多个团队的代码示例,包括将人员列表随机化并根据组数分配到不同组,最后按组号排序显示结果... 目录C#创建人名或其他物体随机分组此示例使用以下代码将人员分配到组代码首先将lstPeople ListBox总结C#创建人名或其他物体随机分组
阅读更多...
在C#中合并和解析相对路径方式

在C#中合并和解析相对路径方式

《在C#中合并和解析相对路径方式》Path类提供了几个用于操作文件路径的静态方法,其中包括Combine方法和GetFullPath方法,Combine方法将两个路径合并在一起,但不会解析包含相对元素... 目录C#合并和解析相对路径System.IO.Path类幸运的是总结C#合并和解析相对路径对于 C
阅读更多...
C#中字符串分割的多种方式

C#中字符串分割的多种方式

《C#中字符串分割的多种方式》在C#编程语言中,字符串处理是日常开发中不可或缺的一部分,字符串分割是处理文本数据时常用的操作,它允许我们将一个长字符串分解成多个子字符串,本文给大家介绍了C#中字符串分... 目录1. 使用 string.Split2. 使用正则表达式 (Regex.Split)3. 使用
阅读更多...
C# Task Cancellation使用总结

C# Task Cancellation使用总结

《C#TaskCancellation使用总结》本文主要介绍了在使用CancellationTokenSource取消任务时的行为,以及如何使用Task的ContinueWith方法来处理任务的延... 目录C# Task Cancellation总结1、调用cancellationTokenSource.
阅读更多...
C# dynamic类型使用详解

C# dynamic类型使用详解

《C#dynamic类型使用详解》C#中的dynamic类型允许在运行时确定对象的类型和成员,跳过编译时类型检查,适用于处理未知类型的对象或与动态语言互操作,dynamic支持动态成员解析、添加和删... 目录简介dynamic 的定义dynamic 的使用动态类型赋值访问成员动态方法调用dynamic 的
阅读更多...
基于Redis有序集合实现滑动窗口限流的步骤

基于Redis有序集合实现滑动窗口限流的步骤

《基于Redis有序集合实现滑动窗口限流的步骤》滑动窗口算法是一种基于时间窗口的限流算法,通过动态地滑动窗口,可以动态调整限流的速率,Redis有序集合可以用来实现滑动窗口限流,本文介绍基于Redis... 滑动窗口算法是一种基于时间窗口的限流算法，它将时间划分为若干个固定大小的窗口，每个窗口内记录了该时间
阅读更多...
C#如何优雅地取消进程的执行之Cancellation详解

C#如何优雅地取消进程的执行之Cancellation详解

《C#如何优雅地取消进程的执行之Cancellation详解》本文介绍了.NET框架中的取消协作模型,包括CancellationToken的使用、取消请求的发送和接收、以及如何处理取消事件... 目录概述与取消线程相关的类型代码举例操作取消vs对象取消监听并响应取消请求轮询监听通过回调注册进行监听使用Wa
阅读更多...
通过C#和RTSPClient实现简易音视频解码功能

通过C#和RTSPClient实现简易音视频解码功能

《通过C#和RTSPClient实现简易音视频解码功能》在多媒体应用中,实时传输协议（RTSP）用于流媒体服务,特别是音视频监控系统,通过C#和RTSPClient库,可以轻松实现简易的音视... 目录前言正文关键特性解决方案实现步骤示例代码总结最后前言在多媒体应用中，实时传输协议（RTSP）用于流媒体服
阅读更多...
C#图表开发之Chart详解

C#图表开发之Chart详解

《C#图表开发之Chart详解》C#中的Chart控件用于开发图表功能,具有Series和ChartArea两个重要属性,Series属性是SeriesCollection类型,包含多个Series对... 目录OverviChina编程ewSeries类总结OverviewC#中，开发图表功能的控件是Char
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2