两种可以在Foreach中遍历的集合类

下面的代码示例阐释如何编写可与 foreach 一起使用的非泛型集合类。 该类是字符串标记化拆分器，类似于 C 运行时函数 strtok_s。

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Collections;
 6 
 7 namespace Macaco.Study.ConsoleProject
 8 {
 9     /*
10      * 注意：数组下标在下文中称为“索引”或“索引位置”
11      */
12     public class Each_Inherit:IEnumerable
13     {
14         //创建用于存放字符串的数组
15         private string[] elements;
16 
17         /// <summary>
18         /// 赋值构造
19         /// </summary>
20         /// <param name="source">数据</param>
21         /// <param name="delimiters">分隔符</param>
22         public Each_Inherit(string source, char[] delimiters)
23         {
24             //将字符串按指定的分隔符分割到字符串数组中
25             elements = source.Split(delimiters);
26         }
27 
28         /// <summary>
29         /// 返回一个循环访问集合的枚举器。
30         /// </summary>
31         /// <returns>可用于循环访问集合的 System.Collections.IEnumerator 对象。</returns>
32         public IEnumerator GetEnumerator()
33         {
34             return new Each_InheritEnum(this);
35         }
36 
37         /// <summary>
38         /// 循环访问集合的枚举器类
39         /// </summary>
40         public class Each_InheritEnum:IEnumerator
41         {
42             //创建当前遍的索引位置
43             private int position = -1;
44 
45             //创建要在Foreach中遍历的对象
46             private Each_Inherit ea;
47 
48             /// <summary>
49             /// 赋值构造
50             /// </summary>
51             /// <param name="ea">要在Foreach中遍历的对象</param>
52             public Each_InheritEnum(Each_Inherit ea)
53             {
54                 this.ea = ea;
55             }
56 
57             /// <summary>
58             /// 返回当前索引所对应的对象
59             /// </summary>
60             public object Current
61             {
62                 get { return ea.elements[position]; }
63             }
64 
65             /// <summary>
66             /// 设置下一轮循环的索引位置
67             /// </summary>
68             /// <returns>返回是否继续下一轮循环</returns>
69             public bool MoveNext()
70             {
71                 if (position < ea.elements.Length - 1)
72                 {
73                     position++;
74                     return true;
75                 }
76                 else
77                 {
78                     return false;
79                 }
80             }
81 
82             /// <summary>
83             /// 重置当前索引位置
84             /// </summary>
85             public void Reset()
86             {
87                 position = -1;
88             }
89         }
90     }
91 }
92 

　　在 C# 中，集合类不一定要从 IEnumerable 和 IEnumerator 继承以便与 foreach 兼容。 只要此类具有必需的 GetEnumerator、 MoveNext、 Reset 和 Current 成员，就可 foreach 与一起使用。 省略接口有一个好处：您可以将 Current 的返回类型定义得比 Object 更为明确，从而提供类型安全。

例如以下代码： 

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace Macaco.Study.ConsoleProject
 7 {
 8     public class Each_NOInherit
 9     {
10         public string[] elements;
11 
12         public Each_NOInherit(string source,char[] delimiters)
13         {
14             elements = source.Split(delimiters);
15         }
16 
17         /// <summary>
18         /// 返回一个循环访问集合的枚举器。
19         /// </summary>
20         /// <returns>可用于循环访问集合的Each_NoInheritEnum对象。</returns>
21         public Each_NOInheritEnum GetEnumerator()
22         {
23             return new Each_NOInheritEnum(this);
24         }
25 
26         /// <summary>
27         /// 循环访问集合的枚举器类
28         /// </summary>
29         public class Each_NOInheritEnum
30         {
31             private int position=-1;
32 
33             private Each_NOInherit ea;
34 
35             public Each_NOInheritEnum(Each_NOInherit ea)
36             {
37                 this.ea = ea;
38             }
39 
40             /// <summary>
41             /// 返回当前索引所对应的字符串
42             /// </summary>
43             public string Current
44             {
45                 get { return ea.elements[position]; }
46             }
47 
48             public bool MoveNext()
49             {
50                 if (position < ea.elements.Length - 1)
51                 {
52                     position++;
53                     return true;
54                 }
55                 else 
56                 {
57                     return false;
58                 }
59             }
60 
61             public void Resset()
62             {
63                 position = -1;
64             }
65         }
66     }
67 }
68 

 

 

下现是调用这两个集合类的主函数：

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace Macaco.Study.ConsoleProject
 7 {
 8     class Program
 9     {
10         static void Main(string[] args)
11         {
12             Each_Test();
13         }
14         private static void Each_Test()
15         {
16             //该类继承自IEnumerable接口，实现接口方法GetEnumerator
17             Each_Inherit ea = new Each_Inherit("This is Each_Inherit Test", new char[] { ' ', '_' });
18 
19             Console.WriteLine("-------Inherit Result-------");
20             foreach (string str in ea)
21             {
22                 Console.WriteLine(str);
23             }
24             Console.WriteLine("----------------------------");
25 
26             Console.WriteLine();
27 
28             //该类没有继承自IEnumerable，但是具有GetEnumerator方法
29             Each_NOInherit eaNo = new Each_NOInherit("This is Each_NO_Inherit Test", new char[] { ' ', '_' });
30 
31             Console.WriteLine("------No Inherit Result-----");
32             foreach (string str in eaNo)
33             {
34                 Console.WriteLine(str);
35             }
36             Console.WriteLine("----------------------------");
37         }
38         /*OutPut:
39          * -------Inherit Result-------
40          *  This
41          *  is
42          *  Each
43          *  Inherit
44          *  Test
45          * ----------------------------
46          * 
47          * ------No Inherit Result-----
48          *  This
49          *  is
50          *  Each
51          *  NO
52          *  Inherit
53          *  Test
54          * ----------------------------
55          */
56 
57        /* 
58         *第一种：实现IEnumerable和IEnumerator接口
59         *第二种：不实现任何接口，但具备以上两个接口中需要实现的方法
60         *优缺点：
61         *  1.第一种集合类能够与其他公共语言运行时 兼容语言的 foreach 语句或等效项交互操作，而第二种不能。 
62         *  2.第一种集合类不可以将 Current 的返回类型定义得比 Object 更为明确，因此无法提供类型安全，
63         *    而第二种集合类可以将Current的返回定义为string从而能够提供更好的类型安全。
64         */
65     }
66 }
67