Здравствуйте, Serginio1, Вы писали:

S>Ты совсем не читаешь. Издеваешься. Ленивость это когда код начинается вызваться не до создания итератора, а после его создания.
S>https://rsdn.org/article/csharp/CSharp_Iterators.xml

Автор(ы): Тепляков Сергей Владимирович
Дата: 23.06.2011
В статье рассматривается шаблон проектирования «Итератор» в контексте языка проектирования C#, включая особенности реализации блока итератора компилятором языка.

S>

S>Можно сказать, что каждый блок кода, между операторами yield return выполняется отложенно (lazily) только после очередного вызова метода MoveNext. Именно на этом основана ленивость библиотеки LINQ, которая построена в виде методов расширения интерфейсов IEnumerable и IEnumerable<T>.

Ты сам то пробовал итераторы реализовывать? В итераторе до вызова MoveNext вообще ничего не происходит, хоть с yield, хоть без него.

S> Тебе обязательно нужно поставить минус!!!!

Именно, потому как ты не в курсе, как работает обычный итератор, который насквозь ленивый даже без yield.

I>>>>Четвертый раз — вместо x[i] у тебя MoveNext, проход через switch, присваивание Current и чтение Current
I>>>>И вот эта каша крайне плохо инлайнится, а следовательно ест больше чем весит.
I>>>>Заметь — это уже в четвертый раз я пишу, а до тебя не доходит.

S> Ты издеваешься? Я тебе привожу ссылки где написано, что ленивости там никакой нет.

Какой ленивости нет в обычном итераторе? До вызова MoveNext у тебя ничего не выполняется.

То есть

const iterator = new CoolIterator(); // уп, нет того списка, который якобы надо создать :-) 
// вот здесь у нас отработал только конструктор итератора, и ничего больше. Никакого копирования данных, вообще ничего нет.

iterator.MoveNext() // вот здесь обработали первую порцию данных. Ровно одну, и ничего больше.

И так всегда, независимо от того, как мы получили CoolIterator — через yield, или написали руками.

S>Ты должен доказать, что товарищ не прав!

Именно. Ты не в курсе, как работает итератор и почему он сам по себе ленивй и был ленивым во все времена до введения yield.
Все, что делает yield, это генерирует итератор. Но это не добавляет ленивости, только уменьшает количество кода.

I>>А ты, упорный. Раз я с тобой не согласен, значит — против yield
S>Минус за что!

За то, что пишешь ересь. Покажи, где тут список, который создаётся:

public class CoolIterator : IEnumerator
{
    int i = 0;

    public CoolIterator()
    {
        _people = list;
    }

    public bool MoveNext()
    {
        i++;
        return true;
    }

    public void Reset()
    {
        i = 0;
    }

    object IEnumerator.Current
    {
        get
        {
            return Current;
        }
    }

    public Person Current
    {
        get
        {
           return i; 
        }
    }
}

Валяй, ищи список.

I>> Что значит "ленивое создание итераторов" ? Он и до введения yield создавался только по требованию, т.е. ленивым образом. А сам итератор и без тебя ленивый.
S>List создается то того как дергается его MoveNext, и дергает родительский MoveNext!!!

Это совсем не обязательно. Никакого list может и не быть. Смотри пример.

I>>Нет, не понятно. Итератор сам по себе ленивый, и так было до yield. И создавался ленивым образом, тоже до yield.
S>Дааааа. То есть ты про List так и не ответил.

Раскрой глаза — какой еще лист? Если мне зачем то понадобился итератор, это совсем необязательно значит, что и какой то лист или массив есть.
Может — да, может — нет.

I>>Так было и до введения yield. Это бенефиты IEnumerable, они работают и без yield.
S> Еще раз List это IEnumerable но он нихрена не ленив.

Я выше привел пример кода, покажи где там недостаток ленивости

I>>Именно. x[0] инлайнится враз и стоит считай бесплатно. А x.FirstOrDefault() в сравнении с этим неимоверно дорог.
I>>Например, когда эта операция одна из основных в экспоненциальном алгоритме, любая издержка дает конское отставание.
S>То есть выполнить 5 создания классов, вызов лямбд будет больше чем миллионы вызовов [x] лямбд и селектов.

Не надо фантазий.
Есть алгоритм в котором if(x[0] == pattern) {return} ; выполняется много раз.
А это значит, что ты предлагаешь x[0] заменить на кучу приседаний через yield, т.е. if(x.First() == pattern) {return}
То есть, в чистом виде замедление.
Когда это становится узким местом — нужно выбросить linq.


I>>Не смеши людей. Я портировал часть Linq и ODATA на JavaScript, а что сделал ты ?
S> Ну ты молодец!! Я так херню всякую пишу и тебе в подметки не гожусь.

Не в курсе, на что ты годишься, но ты даже не понимаешь, что ODATA в дотнете что на клиенте, что на сервере работает через Linq.

I>>А зачем мне list если мне нужна только итерация? Создаем итератор, итерируемся, пока это нужно, профит. Все что надо — один класс создаём явно. yield — делает ровно то же, но не явно. Вся разница. И ленивости в каждом случае ровно одинаково.
S> Какой итератор ты создаешь? List тоже итератор

Я привел пример кода

I>>Разобрался примерно в 2003м году на корутинах Питона, а в 2008 нашел в С# yield
S>Ну тогда за что минус!!

За то, что ересь пишешь.