迭代器模式随想

转载 micDavid 2019/9/4 21:26:52

一、什么是迭代器模式?定义:提供一种顺序访问集合的方法,而不暴露集合内部的表示顺序访问,y(挨个访问),不暴露集合内部表示,反映了面向对象程序中的封装性。可以这么理解,一组模特从后台出场,一个接着一个,但是先出场的模特,未必是站在最前面的模特。换句话说,对于观众,你不知道后台模

一、什么是迭代器模式?

定义:提供一种顺序访问集合的方法,而不暴露集合内部的表示

顺序访问,one by one(挨个访问),不暴露集合内部表示,反映了面向对象程序中的封装性。可以这么理解,一组模特从后台出场,一个接着一个,但是先出场的模特,未必是站在最前面的模特。换句话说,对于观众,你不知道后台模特的特定位置。为什么是顺序访问呢?因为迭代器模式采用的输出机制是内部决定好的,你无法决定。不像字典类型,我传不同的key,可以访问不同的value。我们访问列表,可以直接访问第i个元素,但是迭代器,你想要访问下一个元素,必须把当前的元素访问过后,才能到下一个元素。

二、c#中的迭代器接口

 

 迭代器接口,可以手动实现调用,如下:

 1     public class MyIEnumerator : IEnumerator<string>
 2     {
 3         string[] types = { "下等马", "上等马", "中等马" };
 4 
 5         int cur = -1;
 6         public string Current
 7         {
 8             get
 9             {
10                 return types[cur];
11             }
12         }
13         object IEnumerator.Current
14         {
15             get
16             {
17                 return this.Current;
18             }
19         }
20 
21         public void Dispose()
22         {
23         }
24 
25         public bool MoveNext()
26         {
27             if (cur < types.Length - 1)
28             {
29                 cur++;
30                 return true;
31             }
32             return false;
33         }
34 
35         public void Reset()
36         {
37             cur = -1;
38         }
39     }

话说田忌赛马,按一定的出场顺序赢得了齐威王,此策略是由孙膑提出的,再看看调用:

1      MyIEnumerator m = new MyIEnumerator();
2      while (true)
3       {
4           if (m.MoveNext()) { Console.WriteLine(m.Current); }
5           else break;
6       }

显然手动编写代码,比较麻烦,搞不好还弄个数组越界,我们看看c#中可枚举接口:

 

 此接口只有一个实现迭代器的方法,我们知道凡是实现了这个接口的,都可以用foreach循环,我们把调用迭代器的方法改成foreach自动调用

 1    public class MyEnumerable : IEnumerable<string>
 2     {
 3         public IEnumerator<string> GetEnumerator()
 4         {
 5             return new MyIEnumerator();
 6         }
 7 
 8         IEnumerator IEnumerable.GetEnumerator()
 9         {
10             return GetEnumerator();
11         }
12     }
1   MyEnumerable a = new MyEnumerable();
2    foreach (var item in a)
3    {
4        Console.WriteLine(item);
5    }

可能有人问了,你改成foreach循环和手动循环调用有什么区别?可以这么说吧,foreach进一步简化了调用,你不用控制循环什么时候结束,你也不要操心怎么访问下一个元素。

可见迭代器的调用已经很优雅了,如果迭代器的创建能够简化,那么就更好了,c#中提供了yield关键字。

1         public IEnumerator<string> GetEnumerator()
2         {
3             yield return "下等马";
4             yield return "上等马";
5             yield return "中等马";
6         }

通过6行代码,编译器就为我们创建好了迭代器,如下所示:

 1 public class MyEnumerable : IEnumerable<string>, IEnumerable
 2 {
 3     // Methods
 4     [IteratorStateMachine(typeof(<GetEnumerator>d__0))]
 5     public IEnumerator<string> GetEnumerator()
 6     {
 7         yield return "下等马";
 8         yield return "上等马";
 9         yield return "中等马";
10     }
11 
12     IEnumerator IEnumerable.GetEnumerator()
13     {
14         return this.GetEnumerator();
15     }
16 
17     // Nested Types
18     [CompilerGenerated]
19     private sealed class <GetEnumerator>d__0 : IEnumerator<string>, IDisposable, IEnumerator
20     {
21         // Fields
22         private int <>1__state;
23         private string <>2__current;
24         public MyEnumerable <>4__this;
25 
26         // Methods
27         [DebuggerHidden]
28         public <GetEnumerator>d__0(int <>1__state)
29         {
30             this.<>1__state = <>1__state;
31         }
32 
33         private bool MoveNext()
34         {
35             switch (this.<>1__state)
36             {
37                 case 0:
38                     this.<>1__state = -1;
39                     this.<>2__current = "下等马";
40                     this.<>1__state = 1;
41                     return true;
42 
43                 case 1:
44                     this.<>1__state = -1;
45                     this.<>2__current = "上等马";
46                     this.<>1__state = 2;
47                     return true;
48 
49                 case 2:
50                     this.<>1__state = -1;
51                     this.<>2__current = "中等马";
52                     this.<>1__state = 3;
53                     return true;
54 
55                 case 3:
56                     this.<>1__state = -1;
57                     return false;
58             }
59             return false;
60         }
61 
62         [DebuggerHidden]
63         void IEnumerator.Reset()
64         {
65             throw new NotSupportedException();
66         }
67 
68         [DebuggerHidden]
69         void IDisposable.Dispose()
70         {
71         }
72 
73         // Properties
74         string IEnumerator<string>.Current
75         {
76             [DebuggerHidden]
77             get
78             {
79                 return this.<>2__current;
80             }
81         }
82 
83         object IEnumerator.Current
84         {
85             [DebuggerHidden]
86             get
87             {
88                 return this.<>2__current;
89             }
90         }
91     }
92 }

有趣的是编译器用switch case 实现MoveNext方法,yield用状态机实现迭代器。

三、理解yield关键字

yield关键字,后面紧跟return 表达式或者break。return 表达式,并没有结束迭代器,只是暂时离开迭代器,在特定情况下(调用MoveNext方法时),又会进入迭代器。可以理解迭代器处于暂停或者挂起状态。break直接结束迭代。

四、迭代器的其它用途

Linq表达式的延迟加载,如果我们有一个数组,想通过Linq过滤一下:

 

  List<int> ages =new List<int> { 5, 17, 30, 40 };
  var yong = ages.Where(g => g < 18);

  ages.Add(2);

   foreach (var item in yong)
   {
      Console.WriteLine(item);
   }

 

运行结果:

 

Where扩展方法只是生成了一个迭代器,告诉这个迭代器原始的集合,以及如何筛选的方法,到调用的时候,才真正的过滤数据,这就是Linq延迟加载的原理。

 

上一篇:C#开发BIMFACE系列17 服务端API之获取模型数据2:获取构件材质列表

下一篇:Netty源码分析 (一)----- NioEventLoopGroup

赞(0)

共有 条评论 网友评论

验证码: 看不清楚?
    扫一扫关注最新编程教程