设计模式实践-迭代器模式

场景

实现迭代器模式，迭代仪表集合

实现代码

迭代器接口

namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 迭代器接口
    /// </summary>
    public interface IIterator
    {
        /// <summary>
        /// 获取下一个
        /// </summary>
        /// <returns>仪表接口对象</returns>
        Meter Next();
    }
}

仪表迭代器实现

namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 仪表迭代器类
    /// </summary>
    public class MeterIterator : IIterator
    {
        /// <summary>
        /// 仪表聚合类
        /// </summary>
        private MeterAggregate _meterAggregate;

        /// <summary>
        /// 当前索引
        /// </summary>
        private int _current = -1;

        /// <summary>
        /// Initializes a new instance of the <see cref="MeterIterator" /> class.
        /// </summary>
        /// <param name="meterAggregate">仪表聚合类</param>
        public MeterIterator(MeterAggregate meterAggregate)
        {
            this._meterAggregate = meterAggregate;
        }

        /// <summary>
        /// 获取下个仪表
        /// </summary>
        /// <returns>仪表对象</returns>
        public Meter Next()
        {
            this._current++;
            return this._current >= this._meterAggregate.Count ? null : this._meterAggregate[this._current];
        }
    }
}

仪表聚合接口

namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 仪表接口
    /// </summary>
    public interface IMeterAggregate
    {
        /// <summary>
        /// 创建迭代器
        /// </summary>
        /// <returns>迭代器</returns>
        IIterator CreateIterator();
    }
}

仪表聚合实现

namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 仪表实现类
    /// </summary>
    public class MeterAggregate : IMeterAggregate
    {
        /// <summary>
        /// 仪表集合
        /// </summary>
        private readonly IList<Meter> _meters = new List<Meter>();

        /// <summary>
        /// 获取仪表数量
        /// </summary>
        public int Count => this._meters.Count;
        
        /// <summary>
        /// 申明索引
        /// </summary>
        /// <param name="index">索引号</param>
        /// <returns>仪表对象</returns>
        public Meter this[int index]
        {
            get
            {
                return this._meters[index];
            }

            set
            {
                this._meters.Insert(index, value);
            }
        }

        /// <summary>
        /// 创建一个迭代器
        /// </summary>
        /// <returns>迭代器对象</returns>
        public IIterator CreateIterator()
        {
            return new MeterIterator(this);
        } 
    }
}

仪表实现

namespace DesignPatterns.Iterator
{
    /// <summary>
    /// 仪表对象
    /// </summary>
    public class Meter
    {
        /// <summary>
        /// 仪表ID
        /// </summary>
        private int _id;

        /// <summary>
        /// Initializes a new instance of the <see cref="Meter" /> class.
        /// </summary>
        /// <param name="id">仪表id</param>
        public Meter(int id)
        {
            this._id = id;
        }

        /// <summary>
        /// 仪表动作
        /// </summary>
        public void Action()
        {
            Console.WriteLine($"MeterId: {this._id}");
        }
    }
}

相关调用

Iterator.Meter meter1 = new Iterator.Meter(1);
Iterator.Meter meter2 = new Iterator.Meter(2);
Iterator.Meter meter3 = new Iterator.Meter(3);
Iterator.Meter meter4 = new Iterator.Meter(4);
Iterator.Meter meter5 = new Iterator.Meter(5);
Iterator.MeterAggregate meterAggregate = new Iterator.MeterAggregate();
meterAggregate[0] = meter1;
meterAggregate[1] = meter2;
meterAggregate[2] = meter3;
meterAggregate[3] = meter4;
meterAggregate[4] = meter5;

Iterator.MeterIterator meterIterator = new MeterIterator(meterAggregate);
while (true)
{
    var meter = meterIterator.Next();
    if (meter == null)
        break;
    meter.Action();
}

Out：

MeterId: 1
MeterId: 2
MeterId: 3
MeterId: 4
MeterId: 5