Słowo kluczowe yield pozwala na przygotowanie niestandardowych iteracji dokonywanych na kolekcjach. Możemy wyróżnić dwa scenariusze w których użycie słowa kluczowego yield może okazać się przydatne:

• niestandardowe operacje przeprowadzane na kolekcji bez potrzeby tworzenia kolekcji tymczasowej;
• przechowywanie informacji o tym co się zdarzyło bądź zmieniło od czasu uruchomienia aplikacji, a ściślej, w trakcie wykonywanie operacji na naszej kolekcji (stateful iteration).

Niestandardowe operacje najłatwiej będzie zrozumieć na gotowym przykładzie.
Załóżmy, że mamy prostą listę o nazwie MyList, która składa się z 5 liczb całkowitych: 1, 2, 3, 4, 5. Lista te jest przetwarzana z poziomu głównej metody aplikacji konsolowej, tj. Main().

Nasza metoda Main() będzie przetwarzała elementy listy a następnie wartość danego elementu wypisze w konsoli:

using System;
using System.Collections.Generic;
namespace ListForeach
{
    class Program
    {
        static List<int> MyList = new List<int>();
        static void Main(string[] args)
        {
            FillList();
            foreach (int item in MyList)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
            // Wynik działania programu
            // 1
            // 2
            // 3
            // 4
            // 5
        }
        static void FillList()
        {
            MyList.Add(1);
            MyList.Add(2);
            MyList.Add(3);
            MyList.Add(4);
            MyList.Add(5);
        }
    }
}

static IEnumerable<int> FilterWithoutYield()
{
    List<int> temp = new List<int>();
    foreach (var item in MyList)
    {
        if (item > 3)
            temp.Add(item);
    }
    return temp;
}

static IEnumerable<int> FilterWithYield()
{
    foreach (var item in MyList)
    {
        if (item > 3) yield return item;
    }
}

Omówmy dla przykładu dokładny przepływ kontroli:

• Krok 1 - caller (metoda wywołująca – w naszym przypadku Main()) wywołuje metodę do przetwarzania danych, tj. poszukiwanie wartości większych od 3;
• Krok 2 – wewnątrz metody wykonywana jest pętla, która przechodzi po kolejnych liczbach, aż znajdzie liczbę większą niż 3. Jak tylko liczba taka zostanie wykryta słowo kluczowe yield przekazuje te dane z powrotem do metody wywołującej;
• Krok 3 - caller wyświetla wartość tej liczby w konsoli a następnie wchodzi z powrotem do metody w celu poszukiwania kolejnych liczb. Tym razem nie zaczyna wykonywania metody od nowa a dokładnie od miejsca w którym skończył ostatnio. Pamięta stan i zaczyna sprawdzenie od kolejnej liczby, tj. 5. Iteracja dalej odbywa się jak w powyższym punkcie.

using System;
using System.Collections.Generic;
namespace UsingYield
{
    class Program
    {
        static List<int> MyList = new List<int>();
        static void Main(string[] args)
        {
            // wypełniamy naszą listę danymi
            FillMyList();
            // wywołujemy pętle foreach na naszej metodzie, która zwraca jedynie liczby większe niż 3
            foreach (var item in ListWithYieldReturn())
            {
                // wyświetlamy wartości, które spełniają warunek przez nas zdefiniowany
                Console.WriteLine(item);
            }
            Console.ReadKey();
            // Wynik działania programu
            // 4
            // 5
        }
        static void FillMyList()
        {
            MyList.Add(1);
            MyList.Add(2);
            MyList.Add(3);
            MyList.Add(4);
            MyList.Add(5);
        }
        static IEnumerable<int> ListWithYieldReturn()
        {
            // Przechodzimy po elementach naszej listy
            foreach (var item in MyList)
            {
                // kontrolka do caller'a (metody wywołującej) jest przekazywana jeżeli warunek jest spełniony
                if (item > 3)
                    yield return item;
            }
        }
    }
}

Kolejny przykład musimy nieco bardziej skomplikować. Załóżmy, że chcemy wyświetlić łączną wartość liczb w naszej kolekcji.

Będziemy przeglądać elementy naszej listy od 1 do 5 a w trakcie przeglądania tych wartości będziemy je do siebie dodawać. Zaczynamy od wartości 1, która jako wynik zwraca 1. Następnie przechodzimy do wartości 2 a ogólny wynik w tym przypadku to 3, itd.

Innymi słowy, chcemy przechodzić przez elementy kolekcji oraz zarządzać stanem całkowitym i zwracać tą wartość do naszej metody wywołującej. Zmienna runningTotal będzie cały czas przechowywała starą wartość za każdym razem gdy kontrola zostanie z powrotem przekazana do metody obliczającej sumę:

using System;
using System.Collections.Generic;
namespace YieldState
{
    class Program
    {
        static List<int> MyList = new List<int>();
        static void Main(string[] args)
        {
            FillMyList();
            foreach (var item in RunningTotal())
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
            // Wynik działania programu
            // 1
            // 3
            // 6
            // 10
            // 15
        }
        static IEnumerable<int> RunningTotal()
        {
            int runningTotal = 0;
            foreach (var item in MyList)
            {
                runningTotal += item;
                yield return runningTotal;
            }
        }
        static void FillMyList()
        {
            MyList.Add(1);
            MyList.Add(2);
            MyList.Add(3);
            MyList.Add(4);
            MyList.Add(5);
        }
    }
}