C#:IEnumerable的循环枚举

本文关键字：循环 枚举 IEnumerable | 更新日期: 2023-09-27 18:34:50

我当前的应用程序中有命令层次结构。

public interface ICommand
{
    void Execute();
}
因此，有些

命令是有状态的，有些则不是。

我需要在命令执行期间以循环方式枚举 IEnumerable，以便实现某些命令。

public class GetNumberCommand : ICommand
{
    public GetNumberCommand()
    {
        List<int> numbers = new List<int>
            {
                1, 2, 3
            };
    }
    
    public void Execute()
    {
        // Circular iteration here.
        // 1 => 2 => 3 => 1 => 2 => 3 => ...
    }
    public void Stop()
    {
        // Log current value. (2 for example)
    }
}

Execute 会不时调用，因此需要存储迭代状态。

如何实现该循环枚举？

我找到了两个解决方案：

  1. 使用IEnumerator<T>界面。它看起来像：

     if (!_enumerator.MoveNext())
 {
     _enumerator.Reset();
     _enumerator.MoveNext();
 }

  2. 使用循环IEnumerable<T>(yield永远相同的顺序(："实现循环迭代器" - HonestIllusion.Com。

也许，还有更多方法可以实现它.
您建议使用什么，为什么？

C#:IEnumerable<T>的循环枚举

而不是处理IEnumerator接口，

foreach (var x in GetSomething())
{
     if (someCondition) break;
}

public IEnumerable<int> GetSomething()
{
    List<int> list = new List<int>() { 1, 2, 3 };
    int index=0;
    while (true)
        yield return list[index++ % list.Count];
}
这是我

刚刚作为扩展实现的一个。

using System.Collections;
using System.Collections.Generic;
using System.Linq;
namespace DroopyExtensions
{
    public static class CircularEnumaratorExtensionMethod
    {
        public static IEnumerator<T> GetCircularEnumerator<T>(this IEnumerable<T> t) 
        {
            return new CircularEnumarator<T>(t.GetEnumerator());
        }
        private class CircularEnumarator<T> : IEnumerator<T>
        {
            private readonly IEnumerator _wrapedEnumerator;
            public CircularEnumarator(IEnumerator wrapedEnumerator)
            {
                this._wrapedEnumerator = wrapedEnumerator;
            }
            public object Current => _wrapedEnumerator.Current;
            T IEnumerator<T>.Current =>  (T)Current;
            public void Dispose()
            {
            }
            public bool MoveNext()
            {
                if (!_wrapedEnumerator.MoveNext())
                {
                    _wrapedEnumerator.Reset();
                    return _wrapedEnumerator.MoveNext();
                }
                return true;
            }
            public void Reset()
            {
                _wrapedEnumerator.Reset();
            }
        }
    }   
}

要使用它，您所要做的就是 

using DroopyExtensions;
class Program
{
    static void Main(string[] args)
    {
        var data = new List<string>() {"One", "Two", "Tree"};
        var dataEnumerator = data.GetCircularEnumerator();
        while(dataEnumerator.MoveNext())
        {
            Console.WriteLine(dataEnumerator.Current);
        }
    }
}
您可以使用

此扩展方法：

public static IEnumerable<T> Cyclic<T>(this IEnumerable<T> @this)
{
    while (true)
        foreach (var x in @this)
            yield return x;
}

这样：

public class GetNumberCommand : ICommand
{
    private readonly IEnumerator<int> _commandState = new[] { 1, 2, 3 }.Cyclic().GetEnumerator();
    public void Execute()
    {
        _commandState.MoveNext();
        var state = _commandState.Current;
        
        //
        // Do stuff with state
        //
    }
    public void Stop()
    {
        var state = _commandState.Current;                
        // Log state value. (2 for example)
    }
}

while (!stop)
{
   foreach (var i in numbers)
   {
     // do something
   }
}
我认为

，最舒适的方法是使用自定义枚举器实现自定义集合并将循环逻辑封装在其中。

class Collection<T> : IEnumerable<T>
{
  bool circle;
  List<T> collection = new List<T>();
  public IEnumerable<T> IEnumerable<T>.GetEnumerator()
  {
     if(circle) return new CustomEnumerator<T>(this);
     return circle.GetEnumerator();
  }
}
class CustomEnumerator : Enumerator<T> {}

像这样的东西...

您可以编写一个没有收益回报的可枚举循环。

  public class CircularEnumerable<T> : IEnumerable<T>
  {
    public CircularEnumerable (IEnumerable<T> sequence)
    {
      InfiniteLoop = sequence.Concat (this);
    }
    private readonly IEnumerable<T> InfiniteLoop;
    public IEnumerator<T> GetEnumerator ()
    {
      return InfiniteLoop.GetEnumerator ();
    }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator ()
    {
      return InfiniteLoop.GetEnumerator ();
    }
  }
public class GetNumberCommand : ICommand
{
    public GetNumberCommand()
    {
        List<int> numbers = new List<int>
            {
                1, 2, 3
            };
        infiniteLoopOnNumbers = new CircularEnumerable<int>(numbers).GetEnumerator();
    }
    IEnumerator<int> infiniteLoopOnNumbers; 
    public void Execute()
    {
        infiniteLoopOnNumbers.MoveNext();
    }
    public void Stop()
    {
        int value = infiniteLoopOnNumbers.Current;
    }
}
相关文章：