Quelle est la meilleure façon d'écrire [0..100] en C#?

Question

J'essaie de trouver des façons intelligentes, claires et simples d'écrire du code qui décrit la séquence d'entiers dans une plage donnée.

Voici un exemple:

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

Answer 1

C'est déjà dans le cadre: Enumerable.Range.

Pour les autres types, les classes de plage de ma bibliothèque MiscUtil peuvent vous intéresser.

Answer 2

est ici une idée qui permet un travail de classe gamme avec les deux choses qui sont discrètes et celles qui ne sont pas:

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

Et si vous pensez que fournir le recenseur chaque fois est ennuyeux, voici une classe dérivée:

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

en variante, une interface fluide à partir de méthodes d'extension:

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); 
    } 
} 

utilisé comme:

1.To(100)