What is generator code?

Question

Reading the Google C# style guide I came across this:

Generators vs containers Use your best judgement, bearing in mind: Generator code is often less readable than filling in a container. Generator code can be more performant if the results are going to be processed lazily, e.g. when not all the results are needed. Generator code that is directly turned into a container via ToList() will be less performant than filling in a container directly. Generator code that is called multiple times will be considerably slower than iterating over a container multiple times.

I had little trouble understanding most of the guide, but here I simply don't know what they are talking about! What is "generator code" ?

Answer 1

This code is a generator (Microsoft documentation refer to these as Iterator Methods, see also yield (C# Reference)):

public IEnumerable<string> GetHelloWorld()
{
    yield return "Hello";
    yield return "World";
}

It is a method that generates an iterator enumerable.

They are evaluated lazily, as you probably are aware. That is mentioned in the guideline:

Generator code can be more performant if the results are going to be processed lazily, e.g. when not all the results are needed

On the other hand, we can fill a container and return it:

public IEnumerable<string> GetHelloWorld()
{
    var list = new List();
    list.Add("Hello");
    list.Add("World");
    return list;
}

Not the best way to write that (we could have used a Collection Initializer, for example), but you get the idea.

This code is eager.

A container is just any collection or similar type that contains items. That is why they tell you this:

Generator code that is directly turned into a container via ToList() will be less performant than filling in a container directly.

---

I talk a little more about which one to use in my answer to yield return vs without yield return.

Answer 2

It seems that they are referring to code that generates sequences or lists, usually via LINQ or a yield return. The container they are talking about would be an array or list that has been created from that generator.

To the first point "Generator code is often less readable than filling in a container.": Which is easier to read?

var x = new [] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

Or

IEnumerable<int> CreateNumbers()
{
    for (int i = 0; i < 10; i++)
    {
        yield return i;
    }
}

var x = CreateNumbers().ToArray();

The code to create that simple array via a generator (the second example) is far harder to read than the first one.

"Generator code can be more performant if the results are going to be processed lazily, e.g. when not all the results are needed." Say you have a generator function that will return all integers from 0 to 100,000,000. But say your calling code will process elements until it hits one that is evenly divisible by 10. What this is saying is that the generator will probably be better here because it won't waste the time and space to create a 100,000,000 element array up front when only 10 items will get used. However if you are going to use every element anyway, the generator will be a little slower because of the overhead of using a yield return.

"Generator code that is directly turned into a container via ToList() will be less performant than filling in a container directly." Goes back to the previous point that there is overhead associated with using yield return. If you can skip that, you will be better off.

"Generator code that is called multiple times will be considerably slower than iterating over a container multiple times." If you need to use a sequence more than once, generate it once and save it to use multiple times. It's faster and cheaper to generate once and reuse many times than to generate multiple times.