服务器之家：专注于VPS、云服务器配置技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - C# - C#设计模式实现之迭代器模式

C#设计模式实现之迭代器模式

2022-11-29 12:19SpringSun C#

迭代器模式把对象的职责分离,职责分离可以最大限度减少彼此之间的耦合程度,从而建立一个松耦合的对象,这篇文章主要给大家介绍了关于C#设计模式实现之迭代器模式的相关资料,需要的朋友可以参考下

前言：

迭代器模式平时用的不多，因为不管C#还是Java都已经帮我封装了，但是你是否知道平时经常在用的东西本质是怎么回事呢。

看完迭代器模式你就知道C# foreach循环是怎么实现的了，我的另一篇C# Foreach循环本质与枚举器就讲解了foreach的本质，其中用到的就是迭代器模式。

按照惯例，例子走起。（写了几个小时浏览器崩溃，我看见在自动保存啊，结果没内容，再撸一遍精简点的吧）

一、餐馆合并菜单

现在有两个餐馆和并，其中一个餐馆做早餐，一个做晚餐。他们都有自己管理菜单的方式，现在两个餐馆合并需要对菜单进行统一管理，先让我来看看他们原来的样子。

两个菜单的菜单项都是一样的

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MenuItme
{
    //名字
    public string Name { get; set; }
    //描述
    public string Description { get; set; }
    //是否素菜
    public bool Vegetarian { get; set; }
    //价格
    public double Price { get; set; }
 
    public MenuItme(string name, string description, bool vegetarian, double price) {
        Name = name;
        Description=description;
        Vegetarian = vegetarian;
        Price = price;
    }
}

　　早餐菜单，使用List管理，不限制长度

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class BreakFastMenu
{
    private List<MenuItme> menuItmes;
    public BreakFastMenu()
    {
        menuItmes = new List<MenuItme>();
        AddItem("梅菜扣肉饼", "好吃", false, 7);
        //菜单项...
    }
 
    public void AddItem(string name, string description, bool vegetarian, double price)
    {
        MenuItme menuItme = new MenuItme(name, description, vegetarian, price);
        menuItmes.Add(menuItme);
    }
 
    public List<MenuItme> GetMenuItmes()
    {
        return menuItmes;
    }
}

　　晚餐菜单，使用数组管理，限制长度为6

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class DinerMenu
{
    static readonly int Max_Items = 6;
    private int numberOfImtes = 0;
    private MenuItme[] menuItmes;
    public DinerMenu()
    {
        menuItmes = new MenuItme[Max_Items];
        AddItem("爆炒癞蛤蟆", "讲究火候", false, 42);
        //菜单项...
    }
 
    public void AddItem(string name, string description, bool vegetarian, double price)
    {
        MenuItme menuItme = new MenuItme(name, description, vegetarian, price);
        if (numberOfImtes >= Max_Items)
        {
            Console.WriteLine("菜单已满");
        }
        else
        {
            menuItmes[numberOfImtes] = menuItme;
            numberOfImtes++;
        }
    }
 
    public MenuItme[] GetMenuItmes()
    {
        return menuItmes;
    }
}

　　当两个餐馆合并后需要打印早餐和晚餐菜单给顾客用。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
BreakFastMenu breakFastMenu = new BreakFastMenu();
List<MenuItme> breakFastMenus = breakFastMenu.GetMenuItmes();
 
DinerMenu dinerMenu = new DinerMenu();
MenuItme[] dinerMenus = dinerMenu.GetMenuItmes();
//打印早餐
for (int i = 0; i < breakFastMenus.Count; i++)
{
    Console.WriteLine(breakFastMenus[i].Name);
}
//打印晚餐
for (int i = 0; i < dinerMenus.Length; i++)
{
    Console.WriteLine(dinerMenus[i].Name);
}

按照这种做法我们总是需要处理两个菜单，如果要打印素食，那么也需要循环遍历两个菜单。

假如加入第三家餐厅合并，我们就需要循环处理三次，显然这种方式会让我们系统难以维护。

接下来看我们如何进行改进

二、改进菜单实现

计模式就是要封装变化的部分，很明显，这里变化是：不同的集合类所造成的遍历，我们如何封装遍历集合
不管早餐还是晚餐我们都要用到中括号[ ] 来取菜单项，集合长度来限制长度。
现在我们要创建一个对象，将他称为迭代器（Iterator）,利用它来封装“遍历集合内的每个对象的过程”。

　　对于List

?
1
2
3
4
5
6
Iterator iterator = breakFastMenu.CreateIterator();
while (iterator.HasNext)
{
    MenuItme menuItme = iterator.Next();
 
}

　　对于数组

?
1
2
3
4
5
6
Iterator iterator = dinerFastMenu.CreateIterator();
while (iterator.HasNext)
{
    MenuItme menuItme = iterator.Next();
 
}

现在两个集合的遍历都统一了，而这种方式正是迭代器模式。关于迭代器我们需要知道的第一件事情，就是它依赖于一个迭代器接口。

这个接口可能有HasNext()方法高数我们是否在这个集合中还有更多的元素。

Next()方法返回这个集合中的下一个对象。一旦我们有了这个接口，就可以为各种对象集合实现迭代器。

现在我们对晚餐菜单进行改造，首先我们需要定义一个迭代器接口

?
1
2
3
4
5
public interface Iterator
{
    bool HasNext();
    Object Next();
}

　　加入一个晚餐菜单迭代器

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class DinerMenuIterator : Iterator
{
    MenuItme[] menuItmes;
    int position = 0;
 
    public DinerMenuIterator(MenuItme[] menuItmes)
    {
        this.menuItmes = menuItmes;
    }
    public bool HasNext()
    {
        //由于数组是固定长度，不仅要检查数组，还要检查指定位置是否为空，如果为空后面就没有菜单项了
        if (position >= menuItmes.Length || menuItmes[position] == null)
            return false;
        else
            return true;
    }
 
    public object Next()
    {
        MenuItme menuItme = menuItmes[position];
        position++;
        return menuItme;
    }
}

　　用迭代器改写晚餐菜单

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class DinerMenu
{
    static readonly int Max_Items = 6;
    private int numberOfImtes = 0;
    private MenuItme[] menuItmes;
    public DinerMenu()
    {
        menuItmes = new MenuItme[Max_Items];
        AddItem("爆炒癞蛤蟆", "讲究火候", false, 42);
        //菜单项...
    }
 
    public void AddItem(string name, string description, bool vegetarian, double price)
    {
        MenuItme menuItme = new MenuItme(name, description, vegetarian, price);
        if (numberOfImtes >= Max_Items)
        {
            Console.WriteLine("菜单已满");
        }
        else
        {
            menuItmes[numberOfImtes] = menuItme;
            numberOfImtes++;
        }
    }
    public Iterator CreateIterator()
    {
        return new DinerMenuIterator(menuItmes);
    }
    //public MenuItme[] GetMenuItmes()
    //{
    //    return menuItmes;
    //}
}

　　同理我们为早餐加入迭代器

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class BreakFastIterator: Iterator
{
    List<MenuItme> menuItmes;
    int position = 0;
 
    public BreakFastIterator(List<MenuItme> menuItmes)
    {
        this.menuItmes = menuItmes;
    }
    public bool HasNext()
    {
        if (position >= menuItmes.Count)
            return false;
        else
            return true;
    }
 
    public object Next()
    {
        MenuItme menuItme = menuItmes[position];
        position++;
        return menuItme;
    }
}

　　用迭代器改写早餐菜单

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class BreakFastMenu
{
    private List<MenuItme> menuItmes;
    public BreakFastMenu()
    {
        menuItmes = new List<MenuItme>();
        AddItem("梅菜扣肉饼", "好吃", false, 7);
        //菜单项...
    }
 
    public void AddItem(string name, string description, bool vegetarian, double price)
    {
        MenuItme menuItme = new MenuItme(name, description, vegetarian, price);
        menuItmes.Add(menuItme);
    }
    public Iterator CreateIterator()
    {
        return new BreakFastIterator(menuItmes);
    }
    //public List<MenuItme> GetMenuItmes()
    //{
    //    return menuItmes;
    //}
}

　　好了，让我们试一试迭代器工作情况

C#设计模式实现之迭代器模式

三、迭代器模式

 经过第二步我们基本已经实现迭代器模式，最后我们再改良一下打印菜单，并对菜单进行统一接口的管理。

定义一个Menu接口

?
1
2
3
4
public interface Menu
{
    Iterator CreateIterator();
}

让早餐晚餐都实现Menu接口，并封装一个新的菜单打印

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class NewMenu
{
    Menu breakFastMenu;
    Menu dinerMenu;
    public NewMenu(Menu breakFastMenu, Menu dinerMenu) {
        this.breakFastMenu = breakFastMenu;
        this.dinerMenu = dinerMenu;
    }
 
    public void PrintMenu() {
 
 
        Iterator breakFastIterator = breakFastMenu.CreateIterator();
        Console.WriteLine("新菜单--------早餐");
        PrintMenu(breakFastIterator);
        Console.WriteLine("新菜单--------晚餐");
        Iterator dinerIterator = dinerMenu.CreateIterator();
        PrintMenu(dinerIterator);
    }
 
    private void PrintMenu(Iterator iterator) {
        while (iterator.HasNext())
        {
            //取得下一个项
            MenuItme menuItme = (MenuItme)iterator.Next();
            Console.WriteLine(menuItme.Name);
        }
    }
}

C#设计模式实现之迭代器模式

迭代器模式定义：

迭代器模式：提供一种方法顺序访问一个集合对象中的各个元素，而又不暴露其内部的表示。

迭代器模式让我们能游走于集合内的每一个元素，而又不暴露其内部的表示。

把游走的任务放在迭代器上，而不是集合上。这样简化了集合的接口和实现，也让责任各得其所。

总结

到此这篇关于C#设计模式实现之迭代器模式的文章就介绍到这了,更多相关C#迭代器模式内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://juejin.cn/post/6994227370890641421

  • 设计模式
  • C#
  • 迭代器模式

    • 延伸 · 阅读

    精彩推荐
    • C#一个状态机的实现

      一个状态机的实现

      本文主要介绍了C#实现一个状态机的思路与方法，具有很好的参考价值，下面跟着小编一起来看下吧...

      诺贝尔8512021-12-22
    • C#深入解析C#编程中struct所定义的结构

      深入解析C#编程中struct所定义的结构

      这篇文章主要介绍了C#编程中struct所定义的结构,与C++一样,C#语言同时拥有类和结构,需要的朋友可以参考下...

      C#教程网6992021-11-09
    • C#C# .NET及Mono跨平台实现原理解析

      C# .NET及Mono跨平台实现原理解析

      这篇文章主要介绍了C# .NET及Mono、跨平台实现原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以...

      Fflyqaq5512022-09-07
    • C#C#实现小截屏软件功能

      C#实现小截屏软件功能

      这篇文章主要为大家详细介绍了C#实现截图软件功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      威若·死丢丢8962022-01-07
    • C#C#设置与获取环境变量的方法详解

      C#设置与获取环境变量的方法详解

      这篇文章主要给大家介绍了关于C#设置与获取环境变量的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      fsh0019312022-02-22
    • C#C#控制台实现简单飞行棋游戏

      C#控制台实现简单飞行棋游戏

      这篇文章主要为大家详细介绍了C#控制台实现简单飞行棋游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      梳碧湖-砍柴人5122022-11-27
    • C#C#中RSA加密与解密的实例详解

      C#中RSA加密与解密的实例详解

      这篇文章主要介绍了C#中RSA加密与解密的实例代码，代码简单易懂，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下...

      在代码的世界里游走6592022-08-03
    • C#c# Winform自定义控件-仪表盘功能

      c# Winform自定义控件-仪表盘功能

      这篇文章主要介绍了c#Winform自定义控件-仪表盘功能，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下...

      冰封一夏10892022-08-05
    最近更新
    编辑推荐
    阅读排行
    热门标签
    Span 　 osg 　 刷新桌面 　 nancy 　 TaskManager 　 网站授权 　 下拉式 　 DirectoryEntry 　 C#编程 　 网站功能 　 通知窗口 　 相互关系 　 语句顺序 　 编程错误 　 悬浮框 　 Dispose 　 滚动新闻 　 HttpPost 　 静态构造函数 　 焦点 　 类型派生 　 深度拷贝 　 小写转大写金额 　 任务并行库 　 众数 　 更新数据库 　 统计字数 　 二乘法 　 IComparer 　 DataBinding 　
    © 2019-2022 服务器之家(www.tuohang.net) 版权所有关于我们联系我们版权申明网站地图