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.