Linq unendliche Liste von gegebenen endlichen Liste

Question

Wie kann ich eine endliche Liste von Elementen erstellen, wie ich eine (lazily-evaluated, danke LINQ!) Unendliche Liste erstellen kann, die nur über meine ursprüngliche Liste iteriert?

Wenn die erste Liste {1, 2, 3} ist, möchte ich die neue Liste zurückzukehren {1, 2, 3, 1, 2, 3, 1, ...}

Answer 1

yield return ist ein ziemlich handlicher Operator für dies, obwohl es LINQ spezifisch nicht wirklich erfordert.

IEnumerable<int> GetInfiniteSeries(IEnumerable<int> items) { 
    while (true) { 
     foreach (var item in items) { 
      yield return item; 
     } 
    } 
} 

Answer 2

IEnumerable<T> Infinite(this IEnumerable<T> ienum) 
{ 
    List<T> list = ienum.ToList(); 
    while (true) 
     foreach(var t in list) 
      yield return t; 
} 



foreach(int i in Enumerable.Range(1,3).Infinite()) 
     Console.WriteLine(i); 

Answer 3

hier, wie ich es habe schließlich getan:

public static IEnumerable<T> AdNauseam<T>(this IEnumerable<T> i_list) 
    { 
     using(var etor = i_list.GetEnumerator()) 
     { 
      while(true) 
      { 
       while(etor.MoveNext()) 
       { 
        yield return etor.Current; 
       } 
       etor.Reset(); 
      } 
     } 
    } 

Verbrauch:

var list = new[] {1, 2, 3} 
var infinite = list.AdNauseam().Take(10); 

Das Ergebnis:

{1, 2, 3, 1, 2, 3, 1, 2, 3, 1} 

Answer 4

Eine weitere Option, implementieren IEnumerator<T>:

public class InfiniteEnumerator<T> : IEnumerator<T> 
    { 
     private IList<T> _items; 
     private int _index = -1; 

     public InfiniteEnumerator(IList<T> items) 
     { 
      if (items == null) 
      { 
       throw new ArgumentNullException("items"); 
      } 
      _items = items; 
     } 

     public T Current 
     { 
      get { return _items[_index]; } 
     } 

     public void Dispose() 
     { 

     } 

     object System.Collections.IEnumerator.Current 
     { 
      get { return _items[_index]; } 
     } 

     public bool MoveNext() 
     { 
      if (_items.Count == 0) 
      { 
       return false; 
      } 

      _index = (_index + 1) % _items.Count; 
      return true; 
     } 

     public void Reset() 
     { 
      _index = -1; 
     } 
    }