Я считаю, что последний формат «минимум-максимум» намного понятнее, чем стиль «минимум-количество» Range для этой цели. Кроме того, я не думаю, что это действительно хорошая практика - вносить подобные изменения в норму, которая не быстрее, не короче, не более знакома и не явно яснее.

Тем не менее, я не против идеи в целом. Если бы вы пришли ко мне с синтаксисом, похожим на foreach (int x from 1 to 8), то я, вероятно, согласился бы, что это было бы улучшением по сравнению с циклом for. Однако Enumerable.Range довольно неуклюжий.

Это просто для удовольствия. (Я бы просто использовал стандартный формат цикла «for (int i = 1; i <= 10; i++)».)

foreach (int i in 1.To(10))
{
    Console.WriteLine(i);    // 1,2,3,4,5,6,7,8,9,10
}

// ...

public static IEnumerable<int> To(this int from, int to)
{
    if (from < to)
    {
        while (from <= to)
        {
            yield return from++;
        }
    }
    else
    {
        while (from >= to)
        {
            yield return from--;
        }
    }
}

Вы также можете добавить метод расширения Step:

foreach (int i in 5.To(-9).Step(2))
{
    Console.WriteLine(i);    // 5,3,1,-1,-3,-5,-7,-9
}

// ...

public static IEnumerable<T> Step<T>(this IEnumerable<T> source, int step)
{
    if (step == 0)
    {
        throw new ArgumentOutOfRangeException("step", "Param cannot be zero.");
    }

    return source.Where((x, i) => (i % step) == 0);
}

В C# 6.0 с использованием

using static System.Linq.Enumerable;

вы можете упростить его до

foreach (var index in Range(1, 7))
{
    Console.WriteLine(index);
}

На самом деле вы можете сделать это на С# (предоставив To и Do в качестве методов расширения для int и IEnumerable<T> соответственно):

1.To(7).Do(Console.WriteLine);

SmallTalk навсегда!

Мне нравится идея. Это очень похоже на Python. Вот моя версия в несколько строк:

static class Extensions
{
    public static IEnumerable<int> To(this int from, int to, int step = 1) {
        if (step == 0)
            throw new ArgumentOutOfRangeException("step", "step cannot be zero");
        // stop if next `step` reaches or oversteps `to`, in either +/- direction
        while (!(step > 0 ^ from < to) && from != to) {
            yield return from;
            from += step;
        }
    }
}

Он работает как Python:

• 0.To(4) → [ 0, 1, 2, 3 ]
• 4.To(0) → [ 4, 3, 2, 1 ]
• 4.To(4) → [ ]
• 7.To(-3, -3) → [ 7, 4, 1, -2 ]

Я думаю, что foreach + Enumerable.Range менее подвержен ошибкам (у вас меньше контроля и меньше способов сделать это неправильно, например, уменьшить индекс внутри тела, чтобы цикл никогда не заканчивался и т. д.)

Проблема удобочитаемости связана с семантикой функции диапазона, которая может меняться от одного языка к другому (например, если задан только один параметр, он будет начинаться с 0 или 1, или конец включен или исключен, или второй параметр является счетчиком, а не концом ценность).

Что касается производительности, я думаю, что компилятор должен быть достаточно умен, чтобы оптимизировать оба цикла, чтобы они выполнялись с одинаковой скоростью, даже с большими диапазонами (я полагаю, что Range создает не коллекцию, а, конечно, итератор).

Это кажется довольно длинным подходом к проблеме, которая уже решена. За Enumerable.Range стоит целая машина состояний, которая на самом деле не нужна.

Традиционный формат является основополагающим для развития и знаком всем. Я не вижу никаких преимуществ в твоем новом стиле.

Я думаю, что Range полезен для работы с некоторыми встроенными диапазонами:

var squares = Enumerable.Range(1, 7).Select(i => i * i);

Вы можете каждый над. Требуется преобразование в список, но сохраняет компактность, когда это то, что вам нужно.

Enumerable.Range(1, 7).ToList().ForEach(i => Console.WriteLine(i));

Но кроме чего-то подобного, я бы использовал традиционный цикл for.

Я хотел бы иметь синтаксис некоторых других языков, таких как Python, Haskell и т. д.

// Write the numbers 1 thru 7
foreach (int index in [1..7])
{
    Console.WriteLine(index);
}

К счастью, теперь у нас есть F# :)

Что касается C#, мне придется придерживаться метода Enumerable.Range.

@Luke: я повторно реализовал ваш метод расширения To() и использовал для этого метод Enumerable.Range(). Таким образом, получается немного короче и используется как можно больше инфраструктуры, предоставленной нам .NET:

public static IEnumerable<int> To(this int from, int to)
{ 
    return from < to 
            ? Enumerable.Range(from, to - from + 1) 
            : Enumerable.Range(to, from - to + 1).Reverse();
}

Как использовать новый синтаксис сегодня

Из-за этого вопроса я попробовал некоторые вещи, чтобы придумать хороший синтаксис, не дожидаясь первоклассной языковой поддержки. Вот что у меня есть:

using static Enumerizer;

// prints: 0 1 2 3 4 5 6 7 8 9
foreach (int i in 0 <= i < 10)
    Console.Write(i + " ");

Не разница между <= и <.

Я также создал репозиторий для подтверждения концепции на GitHub с еще большей функциональностью ( обратная итерация, пользовательский размер шага).

Минимальная и очень ограниченная реализация вышеуказанного цикла будет выглядеть примерно так:

public readonly struct Enumerizer
{
    public static readonly Enumerizer i = default;

    public Enumerizer(int start) =>
        Start = start;

    public readonly int Start;

    public static Enumerizer operator <(int start, Enumerizer _) =>
        new Enumerizer(start);

    public static Enumerizer operator >(int _, Enumerizer __) =>
        throw new NotImplementedException();

    public static IEnumerable<int> operator <=(Enumerizer start, int end)
    {
        for (int i = start.Start; i < end; i++)
            yield return i;
    }

    public static IEnumerable<int> operator >=(Enumerizer _, int __) =>
        throw new NotImplementedException();
}

Я уверен, что у каждого есть свои личные предпочтения (многие предпочли бы последнее просто потому, что оно знакомо почти всем языкам программирования), но я, как и вы, начинаю любить foreach все больше и больше, особенно теперь, когда вы можете определить диапазон .

На мой взгляд, способ Enumerable.Range() более декларативен. Новое и незнакомое людям? Безусловно. Но я думаю, что этот декларативный подход дает те же преимущества, что и большинство других языковых возможностей, связанных с LINQ.

Я предполагаю, что могут быть сценарии, в которых Enumerable.Range(index, count) более понятен при работе с выражениями для параметров, особенно если некоторые значения в этом выражении изменяются в цикле. В случае for выражение будет оцениваться на основе состояния после текущей итерации, тогда как Enumerable.Range() оценивается заранее.

Кроме этого, я согласен, что придерживаться for обычно было бы лучше (более знакомый/читабельный для большего количества людей... читаемый - очень важное значение в коде, которое необходимо поддерживать).

Я согласен с тем, что во многих (или даже в большинстве случаев) foreach намного читабельнее, чем стандартный цикл for при простом переборе коллекции. Однако ваш выбор использования Enumerable.Range(index, count) не является убедительным примером ценности foreach для.

Для простого диапазона, начинающегося с 1, Enumerable.Range(index, count), выглядит вполне читаемо. Однако, если диапазон начинается с другого индекса, он становится менее читаемым, потому что вам нужно правильно выполнить index + count - 1, чтобы определить, каким будет последний элемент. Например…

// Write the numbers 2 thru 8
foreach (var index in Enumerable.Range( 2, 7 ))
{
    Console.WriteLine(index);
}

В данном случае я предпочитаю второй пример.

// Write the numbers 2 thru 8
for (int index = 2; index <= 8; index++)
{
    Console.WriteLine(index);
}

Строго говоря, вы неправильно используете перечисление.

Enumerator предоставляет средства для доступа ко всем объектам в контейнере один за другим, но не гарантирует порядок.

Можно использовать перечисление, чтобы найти наибольшее число в массиве. Если вы используете его, чтобы найти, скажем, первый ненулевой элемент, вы полагаетесь на детали реализации, о которых вам не следует знать. В вашем примере порядок кажется вам важным.

Изменить: я ошибаюсь. Как отметил Люк (см. комментарии), безопасно полагаться на порядок при перечислении массива в С#. Это отличается, например, от использования for in для перечисления массива в Javascript.

Мне нравится подход foreach + Enumerable.Range, и я иногда его использую.

// does anyone object to the new style over the traditional style?
foreach (var index in Enumerable.Range(1, 7))

Я возражаю против var злоупотреблений в вашем предложении. Я ценю var, но, черт возьми, просто напишите int в этом случае! ;-)

Просто бросаю свою шляпу на ринг.

Я определяю это...

namespace CustomRanges {

    public record IntRange(int From, int Thru, int step = 1) : IEnumerable<int> {

        public IEnumerator<int> GetEnumerator() {
            for (var i = From; i <= Thru; i += step)
                yield return i;
        }

        IEnumerator IEnumerable.GetEnumerator()
            => GetEnumerator();
    };

    public static class Definitions {

        public static IntRange FromTo(int from, int to, int step = 1)
            => new IntRange(from, to - 1, step);

        public static IntRange FromThru(int from, int thru, int step = 1)
            => new IntRange(from, thru, step);

        public static IntRange CountFrom(int from, int count)
            => new IntRange(from, from + count - 1);

        public static IntRange Count(int count)
            => new IntRange(0, count);

        // Add more to suit your needs. For instance, you could add in reversing ranges, etc.
    }
}

Затем везде, где я хочу его использовать, я добавляю это вверху файла...

using static CustomRanges.Definitions;

И использовать его так...

foreach(var index in FromTo(1, 4))
    Debug.WriteLine(index);
// Prints 1, 2, 3

foreach(var index in FromThru(1, 4))
    Debug.WriteLine(index);
// Prints 1, 2, 3, 4

foreach(var index in FromThru(2, 10, 2))
    Debug.WriteLine(index);
// Prints 2, 4, 6, 8, 10

foreach(var index in CountFrom(7, 4))
    Debug.WriteLine(index);
// Prints 7, 8, 9, 10

foreach(var index in Count(5))
    Debug.WriteLine(index);
// Prints 0, 1, 2, 3, 4

foreach(var _ in Count(4))
    Debug.WriteLine("A");
// Prints A, A, A, A

В этом подходе хорошо то, что по именам вы точно знаете, включен ли конец или нет.