Understanding Yield Return in C#

Introduction

Once you understand having "yield return" in C # code, you will not help wondering what a return form or a special mechanism to handle it is. In the article below, we will learn some programming techniques that revolve around C# yield return keywords.

Quote from MSDN

"The yield keyword signals to the compiler that the method in which it appears is an iterator block. The compiler generates a class to implement the behavior that is expressed in the iterator block. In the iterator block, the yield keyword is used together with the return keyword to provide a value to the enumerator object. This is the value that is returned, for example, in each loop of a foreach statement. The yield keyword is also used with a break to signal the end of the iteration."

Method of operation of yield

When combined with the return mechanism allowing creation, the function returns a value that handles certain information in the loop and puts an end to certain conditions before it. This is contrary to the case of a normal return: I get a return value of the function that will return and finish the function at that point. But here, the function is to call back in the loop containing the yield return function that just ended. From here, we can imagine an action that is rather abstract but can be useful in some cases, to help keep code concise and tight.

Some requirements for the use of yield return

• Do not put "yield" in an unsafe block.
• Do not use ref or out keywords with the parameters of the method, operator, or accessor (getter/setter).
• "Yield return" can only be placed in the try block if it is followed by a final block.
• "Yield break" can be put in the try block and catch but not placed in the final block.
• Do not use the "yield" of the anonymous method.

An example of using yield return

To use "yield return", you just need to create a method with a return type that is an IEnumerable (arrays and collections in. Net implement IEnumerable interface) with a loop and use "yield return" to return a value to set in the loop body.

Some examples are of a function with two arguments (int start, int number) made ​​in even numbers starting from the starting number.

The following is the code written in the usual way, transmitted to them and returns the result as an array and then uses one array to receive the value returned:

using System;
using System.Collection.Generic;
using System.Linq;
using System.Text;
namespace demoYieldReturn 
{
    class Program 
    {
        static void Main() 
        {
            int[] a = new int[10];
            a = func(2, 10);
            for (int i = 0; i < 10; i++) 
            {
                Console.writeLine(a[i]);
            }
            Console.Read();
        }
        public static int[] func(int start, int number) 
        {
            int[] _number = new int[number];
            for (int i = 0; in < number; i++) 
            {
                _number = start + 2 * i;
            }
            return _number;
        }
    }
}

Instead, we can use a yield return to make the code simpler and quick to operate, reducing operating costs through other intermediaries, easy error check code in the case of large volume.

using System;
using System.Collection.Generic;
using System.Linq;
using System.Text;
namespace demoYieldReturn 
{
    class Program 
    {
        static void Main() 
        {
            foreach(var item in func(2,10))
            {
                Console.WriteLine(item);
            }
            Console.Read();
        }
        public static IEnumerable func(int start, int number) 
        {
            for (int i = 0; i < number; i++) 
            {
                yield return start + 2 * i;
            }
        }
    }
}

In the second code, you can set a breakpoint at line 22 and line 14, and the Index for debug functions continues (F5). You will see that the two breakpoints will be activated alternately. This demonstrates that the program can jump back and forth between the two modes without losing their current state.

Conclusion

One advantage of using "yield" that you can see right in the first instance is the number of lines of code is reduced.

Moreover, because two working modes rotate, you do not need to create or get a list of the elements to browse. This applies in cases such as searching and browsing a number of elements required that will reduce the dependency on the location of the element to find.