सी # में [0..100] लिखने का सबसे अच्छा तरीका क्या है?

Question

मैं कोड लिखने के चालाक, स्पष्ट और सरल तरीकों के बारे में सोचने की कोशिश कर रहा हूं जो किसी दिए गए सीमा में पूर्णांक के अनुक्रम का वर्णन करता है।

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

Answer 1

इस ढांचे में पहले से ही है: Enumerable.Range

यहाँ एक उदाहरण है।

अन्य प्रकार के लिए, आपको मेरी MiscUtil लाइब्रेरी में श्रेणी कक्षाओं में रुचि हो सकती है।

Answer 2

यहाँ एक विचार दोनों चीजें हैं जो असतत हैं और वे जो नहीं हैं के साथ एक सीमा वर्ग काम देता है कि है:

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

और अगर आपको लगता है कि प्रगणक हर बार कष्टप्रद है की आपूर्ति, यहाँ एक व्युत्पन्न वर्ग है:

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

वैकल्पिक रूप से, विस्तार के तरीकों से एक धाराप्रवाह इंटरफ़ेस:

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)