#
Python for the .NET Developer Transcripts

Chapter: The Python Language

Lecture: C# generators

Login or
purchase this course
to watch this video and the rest of the course contents.

0:00
This next section, I want to cover something that I think is probably underused in C# and in Python and it's such a cool idea, generators.

0:11
This is the yield return keyword and things like that in C#. So let's look at a real simple example here Fibonacci numbers. So we have two versions.

0:21
We have the naive version of the Fibonacci sequence that you might write and if you don't remember it's 1 and 1 and then you add

0:29
the two numbers together and you get 2 and you add those two to get 2 and 5 and then 8 and then 13 and then 21 and so on.

0:38
Right, so that's the sequence that we're working with here. Here's a simple standard function. Return something IEnumerable of integers

0:46
and you say I would like, I don't know five Fibonacci numbers or six or 1000 or 100,000 and what it does is it creates a list

0:55
it does the algorithm, puts the items in the list as it computes them and when it's done it returns them, great right? This is a standard function

1:03
it returns a basically a list that we can iterate. However, this is an approximation of the Fibonacci numbers in fact, right?

1:12
The Fibonacci sequence is infinite. How do you know how many to ask for? Things like that, it can be tricky. So here's a better one that has no limit.

1:21
See while true and it returns IEnumerable<int> and at each step it uses the yield return keyword to return a single integer.

1:31
So this is how yield return works in C#. We yield return an item of a collection. We say we have a collection of integers

1:38
and here is one and here is one and here's one and it will just keep generating these until we stop asking for them.

1:46
The trick to make this work is we're going to to through them in this foreach loop and get an item out and then if the item is big enough

1:53
then we're going to stop asking. So let's go and run this. Look at it go, runs and runs and runs hits an item, hits an item.

2:02
If we put a breakpoint here this is when it gets pretty interesting. So here we are in our foreach statement

2:07
and if we step in it's going to do what you expect. It goes into the function and great so we're stepping along here. I'll go into while true loop

2:16
it's kind of crazy that that returns out of there but okay that's how these work. So it's going to generate the first item which is 1

2:22
and it's going to return it and go back to the loop, okay? There's one and is equal to 1. We're writing it out and if we keep stepping

2:33
we step back into our Fibonacci sequence but we jump to this line after yield return. Notice even though current started out at 0 it is now 1.

2:44
And this is not because I ran to this place in the function, no. It actually resumes. These are like restartable functions, these generators.

2:53
If we step through here, we're going to do again. Get this, now we're back here and now n is probably 1 again.

3:02
It's going to go 1, 1 and then 2 and so on. So it just keeps pulling them one at a time as we iterate over them. And the result that we get is

3:13
it generates all those until we stop asking for it where we said if it's over a 1000 stop. All right, so this is generators

3:19
and the yield return keyword in C#. Super powerful, it's the foundation of things like the lazy evaluation of things like LINQ for objects and so on.

3:30
I don't think that many people use it but it's really powerful when you want to start work with a collection or generate a collection

3:37
or something like but you're not sure how much you want to take. You want to just pull them one at a time. Really, really nice.

3:43
Yield return keyword, C#, love it.