When should I use Yield in c#?

Question

I have a vage understanding of the Yield keyword in c#, but I haven't yet seen the need to use it in my code. This probably comes from a lack of understanding of it..

So; What are some typical good usages of Yield?

Answer 1

yield just makes it very simple to implement an enumerator. So if you wanted write a method that returns an IEnumerable<T> it saves you having to create the enumerator class - you just yield one result at a time and the compiler takes care of the details under the covers.

One handy case is to write an "infinite enumerator" that the caller can call as many times as it needs to. Here's an example that generates an infinite series of Fibonacci numbers: http://chrisfulstow.com/fibonacci-numbers-iterator-with-csharp-yield-statements/ (well... theoretically infinite, but in practice limited to the size of UInt64).

Answer 2

There is a very good answer regarding the Yield keyword here

Answer 3

Yield implements the pattern of lazy loading. I suggest to consider its usefulness from this perspective.

For example. in the context of business software I'm working on, it could brings the advantage of lowering load on the database. You write code that pulls a variety of data from the database, but only that portion will be loaded which is really needed for a particular scenario. If a user doesn't go deeper in the UI, the respective data will not be loaded.

Answer 4

Yield is used in enumerators. The C# compiler automatically pauses execution of your enumeration loop and returns the current value to the caller.

IEnumerable<int> GetIntegers(int max) {
    for(int i = 1; i <= max) {
         yield return i; // Return current value to the caller
    }
}

-- or (more clunky) --

IEnumerable<int> GetIntegers(int max) {
    int count = 0;
    while(true) {
         if(count >= max) yield break; // Terminate enumeration

         count++;
         yield return count; // Return current value to the caller
    }
}

More details on MSDN.

Answer 5

Also pretty good in testing and mocking when you just want to test an IEnumerable<> quickly, something like...

yield return somevalue;
yield return someothervalue;
yield return yetanotherone;