У C # 3.0 мені подобається такий стиль:

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

над традиційним forциклом:

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

Якщо припустити, що "n" мало, тож продуктивність не є проблемою, чи хтось заперечує проти нового стилю порівняно з традиційним?

Я вважаю, що формат "від мінімального до максимального" останнього набагато зрозуміліший, ніж 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);
}

Ви можете насправді зробити це в C # (надавши 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 менш схильний до помилок (у вас менше контролю та менше способів зробити це неправильно, наприклад, зменшити індекс всередині тіла, щоб цикл ніколи не закінчувався тощо)

Проблема читабельності стосується семантики функції 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();
}

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

На мій погляд, Enumerable.Range()спосіб є більш декларативним. Новий і незнайомий людям? Звичайно. Але я думаю, що цей декларативний підхід приносить ті самі переваги, що й більшість інших мовних функцій, пов'язаних з LINQ.

Як використовувати новий синтаксис сьогодні

Через це запитання я спробував деякі речі, щоб придумати гарний синтаксис, не чекаючи першокласної мовної підтримки. Ось що я маю:

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

Я думаю, що можуть бути сценарії, де Enumerable.Range(index, count)зрозуміліше, коли йдеться про вирази для параметрів, особливо якщо деякі значення у цьому виразі змінюються в циклі. У випадку forвиразу буде обчислюватися на основі стану після поточної ітерації, тоді Enumerable.Range()як обчислюється вперед.

Окрім цього, я б погодився, що дотримуватися for, як правило, було б краще (більш звичним / читабельним для більшої кількості людей ... читабельність - дуже важлива цінність у коді, яку потрібно підтримувати).

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

Для простого діапазону, починаючи з 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);
}

Власне кажучи, ви зловживаєте переліком.

Перерахувач надає засоби доступу до всіх об’єктів у контейнері по одному, але це не гарантує порядок.

Добре використовувати перерахування, щоб знайти найбільше число в масиві. Якщо ви використовуєте його для пошуку, скажімо, першого ненульового елемента, ви покладаєтесь на деталі реалізації, про які ви не повинні знати. У вашому прикладі порядок здається вам важливим.

Редагувати : я помиляюся. Як зазначив Лука (див. Коментарі), безпечно покладатися на порядок при перерахуванні масиву в C #. Це відрізняється від, наприклад, використання "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

Приємним у цьому підході є імена, ви точно знаєте, включений кінець чи ні.