Was ist der beste Weg, [0..100] in C# zu schreiben?

Question

Ich versuche über clevere, klare und einfache Wege nachzudenken, Code zu schreiben, der die Folge von ganzen Zahlen in einem gegebenen Bereich beschreibt.

Hier ist ein Beispiel:

IEnumerable<int> EnumerateIntegerRange(int from, int to) 
{ 
    for (int i = from; i <= to; i++) 
    { 
     yield return i; 
    } 
} 

Answer 1

Dies ist bereits im Rahmen: Enumerable.Range.

Für andere Typen könnten Sie die Bereichsklassen in meiner MiscUtil Bibliothek interessiert sein.

Answer 2

Hier ist eine Idee, die eine Reihe Klasse arbeiten mit beiden Dinge können, die diskrete und solche sind, die nicht sind:

class Range<T> where T: IComparable<T> 
{ 
    public T From { get; set; } 
    public T To { get; set; } 

    public Range(T from, T to) { this.From = from; this.To = to; } 

    public IEnumerable<T> Enumerate(Func<T, T> next) 
    { 
     for (T t = this.From; t.CompareTo(this.To) < 0; t = next(t)) 
     { 
      yield return t; 
     } 
    } 

    static void Example() 
    { 
     new Range<int> (0, 100).Enumerate(i => i+1) 
    } 
} 

Answer 3

Und wenn Sie denken, dass die Aufzählungs Versorgung jedes Mal, hier ist eine abgeleitete Klasse ärgerlich ist:

class EnumerableRange<T> : Range<T>, IEnumerable<T> 
    where T : IComparable<T> 
{ 
    readonly Func<T, T> _next; 
    public EnumerableRange(T from, T to, Func<T, T> next) 
     : base(from, to) 
    { 
     this._next = next; 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
     return Enumerate(this._next).GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return this.GetEnumerator(); 
    } 
} 

Answer 4

Alternativ kann eine fließend Schnittstelle von Erweiterungsmethoden:

public static IEnumerable<int> To(this int start, int end) 
{ 
    return start.To(end, i => i + 1); 
} 

public static IEnumerable<int> To(this int start, int end, Func<int, int> next) 
{ 
    int current = start; 
    while (current < end) 
    { 
     yield return current; 
     current = next(current); 
    } 
} 

1.To(100)