Question

Could you explain me how ‘yield’ keyword works in regards to Enumerable? For ex. I can’t understand how in the code below program returns an object of type IEnumerable:

class Program
    {
        static IEnumerable<T> Merge<T>(IEnumerable<T> left, IEnumerable<T> right)
            where T: IComparable<T>
        {
            IEnumerator<T> l = left.GetEnumerator();
            IEnumerator<T> r = right.GetEnumerator();

            bool l_has_data = l.MoveNext();
            bool r_has_data = r.MoveNext();

            while (l_has_data || r_has_data)
            {
                if (!l_has_data && r_has_data)
                {
                    yield return r.Current;
                    r_has_data = r.MoveNext();
                    continue;
                }
                if (!r_has_data && l_has_data)
                {
                    yield return l.Current;
                    l_has_data = l.MoveNext();
                    continue;
                }

                int comp = l.Current.CompareTo(r.Current);
                if (comp < 0)
                {
                    yield return l.Current;
                    l_has_data = l.MoveNext();
                }
                else if (comp > 0)
                {
                    yield return r.Current;
                    r_has_data = r.MoveNext();
                }
                else
                {
                    yield return l.Current;
                    yield return r.Current;
                    l_has_data = l.MoveNext();
                    r_has_data = r.MoveNext();
                }
            }
        }

If i hover over ‘.Current’ it says me that this ‘Gets the element at the current position of the enumerator’.

Answer 1

What MSDN days :

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.

---

In simple word :

yield return return a Collection of Object instead of returning a single object

    static void Main(string[] args)
    {

        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        // supposed u need to find all the numbers which are greater then 5
        // in general it could have been done like

        foreach (int number in numbers)
        {
            if (number > 5)
            {
                Console.WriteLine(number);
            }

        }

        // what if u needed the numbers that are greater then 5 multiple times, each time you would have to start a loop
        // yield return helps to return a collection of int
        var needed_numbers = NeededNumbers(numbers);

        foreach (int neededNumber in needed_numbers)
        {
            Console.WriteLine(neededNumber);
        }
    }

    private static IEnumerable<int> NeededNumbers(int[] nums)
    {
        foreach (int number in nums)
        {
            if (number > 5)
            {
                yield return number;
            }

        }
    }

---

Quote from DotNetPerls

The yield return statement is semantically equivalent to a return
statement (which passes control flow to the calling method), followed
by a “goto” to the yield statement in the next iteration of the
foreach loop.