C#集合-列举（Enumeration）

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

本文主要是介绍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。

相关文章

2. c#从不同cs的文件调用函数

2. c#从不同cs的文件调用函数

1.文件目录如下： 2. Program.cs文件的主函数如下 using System;using System.Collections.Generic;using System.Linq;using System.Threading.Tasks;using System.Windows.Forms;namespace datasAnalysis{internal static
阅读更多...
C#实战|大乐透选号器[6]：实现实时显示已选择的红蓝球数量

C#实战|大乐透选号器[6]：实现实时显示已选择的红蓝球数量

哈喽，你好啊，我是雷工。 关于大乐透选号器在前面已经记录了5篇笔记，这是第6篇； 接下来实现实时显示当前选中红球数量，蓝球数量； 以下为练习笔记。 01 效果演示 当选择和取消选择红球或蓝球时，在对应的位置显示实时已选择的红球、蓝球的数量； 02 标签名称 分别设置Label标签名称为：lblRedCount、lblBlueCount
阅读更多...
uva 11178 计算集合模板题

uva 11178 计算集合模板题

题意： 求三角形行三个角三等分点射线交出的内三角形坐标。 代码： #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <cmath>#include <stack>#include <vector>#include <
阅读更多...
用命令行的方式启动.netcore webapi

用命令行的方式启动.netcore webapi

用命令行的方式启动.netcore web项目 进入指定的项目文件夹，比如我发布后的代码放在下面文件夹中 在此地址栏中输入“cmd”，打开命令提示符，进入到发布代码目录 命令行启动.netcore项目的命令为:  dotnet 项目启动文件.dll --urls="http://*:对外端口" --ip="本机ip" --port=项目内部端口 例： dotnet Imagine.M
阅读更多...
C# dateTimePicker 显示年月日，时分秒

C# dateTimePicker 显示年月日，时分秒

dateTimePicker默认只显示日期，如果需要显示年月日，时分秒，只需要以下两步： 1.dateTimePicker1.Format = DateTimePickerFormat.Time 2.dateTimePicker1.CustomFormat = yyyy-MM-dd HH:mm:ss Tips:  a. dateTimePicker1.ShowUpDown = t
阅读更多...
C#关闭指定时间段的Excel进程的方法

C#关闭指定时间段的Excel进程的方法

private DateTime beforeTime;            //Excel启动之前时间          private DateTime afterTime;               //Excel启动之后时间          //举例          beforeTime = DateTime.Now;          Excel.Applicat
阅读更多...
C# 防止按钮botton重复“点击”的方法

C# 防止按钮botton重复“点击”的方法

在使用C#的按钮控件的时候，经常我们想如果出现了多次点击的时候只让其在执行的时候只响应一次。这个时候很多人可能会想到使用Enable=false, 但是实际情况是还是会被多次触发，因为C#采用的是消息队列机制，这个时候我们只需要在Enable = true 之前加一句 Application.DoEvents();就能达到防止重复点击的问题。 private void btnGenerateSh
阅读更多...
C# double[] 和Matlab数组MWArray[]转换

C# double[] 和Matlab数组MWArray[]转换

C# double[] 转换成MWArray[], 直接赋值就行             MWNumericArray[] ma = new MWNumericArray[4];             double[] dT = new double[] { 0 };             double[] dT1 = new double[] { 0,2 };
阅读更多...
Java基础回顾系列-第六天-Java集合

Java基础回顾系列-第六天-Java集合

Java基础回顾系列-第六天-Java集合 集合概述数组的弊端集合框架的优点Java集合关系图集合框架体系图java.util.Collection接口 List集合java.util.List接口java.util.ArrayListjava.util.LinkedListjava.util.Vector Set集合java.util.Set接口java.util.HashSetjava
阅读更多...
【408数据结构】散列 （哈希）知识点集合复习考点题目

【408数据结构】散列 （哈希）知识点集合复习考点题目

苏泽  “弃工从研”的路上很孤独，于是我记下了些许笔记相伴，希望能够帮助到大家    知识点 1. 散列查找 散列查找是一种高效的查找方法，它通过散列函数将关键字映射到数组的一个位置，从而实现快速查找。这种方法的时间复杂度平均为(
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2