c# - rellenar - programa que muestre los numeros del 1 al 100 en c

¿Cuál es la mejor manera de escribir[0..100] en C#?

Question

Intento pensar en formas inteligentes, claras y simples de escribir código que describa la secuencia de enteros en un rango determinado.

Aquí hay un ejemplo:

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

Answer 1

Esto ya está en el marco: Enumerable.Range .

Para otros tipos, es posible que le interesen las clases de rango en mi biblioteca MiscUtil .

Answer 2

Alternativamente, una interfaz fluida desde los métodos de extensión:

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

usado como:

1.To(100)

Answer 3

Aquí hay una idea que permite que una clase de rango funcione con ambas cosas, que son discretas y que no son:

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 4

Y si crees que el suministro del enumerador cada vez es molesto, aquí hay una clase derivada:

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