Po co używać słowa kluczowego yield, skoro wystarczy zwykły IEnumerable?

Biorąc pod uwagę ten kod:

IEnumerable<object> FilteredList()
{
    foreach( object item in FullList )
    {
        if( IsItemInPartialList( item ) )
            yield return item;
    }
}

Dlaczego nie miałbym tego po prostu zakodować w ten sposób ?:

IEnumerable<object> FilteredList()
{
    var list = new List<object>(); 
    foreach( object item in FullList )
    {
        if( IsItemInPartialList( item ) )
            list.Add(item);
    }
    return list;
}

W pewnym sensie rozumiem, co yieldrobi słowo kluczowe. Mówi kompilatorowi, aby zbudował pewien rodzaj rzeczy (iterator). Ale po co go używać? Poza tym, że jest nieco mniej kodu, co to robi dla mnie?

Użycie yieldpowoduje, że kolekcja jest leniwa.

Powiedzmy, że potrzebujesz tylko pierwszych pięciu elementów. Na swój sposób muszę przeglądać całą listę, aby uzyskać pierwsze pięć pozycji. W programie przeglądam yieldtylko pierwsze pięć elementów.

Zaletą bloków iteratorów jest to, że działają leniwie. Możesz więc napisać taką metodę filtrowania:

public static IEnumerable<T> Where<T>(this IEnumerable<T> source,
                                   Func<T, bool> predicate)
{
    foreach (var item in source)
    {
        if (predicate(item))
        {
            yield return item;
        }
    }
}

To pozwoli ci filtrować strumień tak długo, jak chcesz, nigdy nie buforując więcej niż jednego elementu na raz. Jeśli na przykład potrzebujesz tylko pierwszej wartości ze zwróconej sekwencji, dlaczego miałbyś chcieć skopiować wszystko do nowej listy?

Jako inny przykład, możesz łatwo utworzyć nieskończony strumień przy użyciu bloków iteratorów. Na przykład, oto sekwencja liczb losowych:

public static IEnumerable<int> RandomSequence(int minInclusive, int maxExclusive)
{
    Random rng = new Random();
    while (true)
    {
        yield return rng.Next(minInclusive, maxExclusive);
    }
}

Jak zapisałbyś nieskończoną sekwencję na liście?

Moja seria blogów Edulinq zawiera przykładową implementację LINQ to Objects, która w dużym stopniu wykorzystuje bloki iteratorów. LINQ jest zasadniczo leniwy tam, gdzie może być - a umieszczanie rzeczy na liście po prostu nie działa w ten sposób.

Z kodem „listy” musisz przetworzyć pełną listę, zanim będziesz mógł przekazać ją do następnego kroku. Wersja „yield” przenosi przetworzony element natychmiast do następnego kroku. Jeśli ten „następny krok” zawiera „.Take (10)”, to wersja „yield” przetworzy tylko pierwsze 10 elementów i zapomni o reszcie. Kod „listy” przetworzyłby wszystko.

Oznacza to, że największą różnicę widać, gdy trzeba dużo przetworzyć i / lub mieć długie listy elementów do przetworzenia.

Możesz użyć, yieldaby zwrócić elementy, których nie ma na liście. Oto mała próbka, która może powtarzać się w nieskończoność po liście, dopóki nie zostanie anulowana.

public IEnumerable<int> GetNextNumber()
{
    while (true)
    {
        for (int i = 0; i < 10; i++)
        {
            yield return i;
        }
    }
}

public bool Canceled { get; set; }

public void StartCounting()
{
    foreach (var number in GetNextNumber())
    {
        if (this.Canceled) break;
        Console.WriteLine(number);
    }
}

To pisze

0
1
2
3
4
5
6
7
8
9
0
1
2
3
4

...itp. do konsoli do czasu anulowania.

object jamesItem = null;
foreach(var item in FilteredList())
{
   if (item.Name == "James")
   {
       jamesItem = item;
       break;
   }
}
return jamesItem;

Gdy powyższy kod jest używany do pętli przez FilteredList () i zakładając, że item.Name == "James" będzie spełniony na 2. pozycji na liście, metoda wykorzystująca yield zwróci dwa razy. To jest leniwe zachowanie.

Gdzie jako metoda używająca list doda wszystkie n obiektów do listy i przekaże pełną listę do metody wywołującej.

To jest dokładnie przypadek użycia, w którym można wyróżnić różnicę między IEnumerable i IList.

Najlepszym przykładem użycia programu w świecie rzeczywistym, jaki widziałem, yieldbyłoby obliczenie ciągu Fibonacciego.

Rozważ następujący kod:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(string.Join(", ", Fibonacci().Take(10)));
        Console.WriteLine(string.Join(", ", Fibonacci().Skip(15).Take(1)));
        Console.WriteLine(string.Join(", ", Fibonacci().Skip(10).Take(5)));
        Console.WriteLine(string.Join(", ", Fibonacci().Skip(100).Take(1)));
        Console.ReadKey();
    }

    private static IEnumerable<long> Fibonacci()
    {
        long a = 0;
        long b = 1;

        while (true)
        {
            long temp = a;
            a = b;

            yield return a;

            b = temp + b;
        }
    }
}

To zwróci:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55
987
89, 144, 233, 377, 610
1298777728820984005

Jest to przyjemne, ponieważ pozwala szybko i łatwo obliczyć nieskończoną serię, dając możliwość korzystania z rozszerzeń Linq i przeszukiwania tylko tego, czego potrzebujesz.

po co używać [yield]? Poza tym, że jest nieco mniej kodu, co to dla mnie robi?

Czasami jest to przydatne, czasami nie. Jeśli cały zestaw danych musi zostać zbadany i zwrócony, nie będzie żadnych korzyści z używania wydajności, ponieważ wszystko, co zrobił, to wprowadzenie narzutu.

Kiedy wydajność naprawdę świeci, jest zwracana tylko część zestawu. Myślę, że najlepszym przykładem jest sortowanie. Załóżmy, że masz listę obiektów zawierającą datę i kwotę w dolarach z tego roku i chciałbyś zobaczyć pierwszą garść (5) rekordów z tego roku.

Aby to osiągnąć, listę należy posortować rosnąco według daty, a następnie wziąć pierwszych 5. Jeśli zrobiono to bez plonów, całość lista musiałaby zostać posortowana, aż do upewnienia się, że ostatnie dwie daty są w porządku.

Jednak z wydajnością po ustaleniu pierwszych 5 pozycji sortowanie zatrzymuje się i wyniki są dostępne. Może to zaoszczędzić dużo czasu.

Instrukcja zwrotu zysku umożliwia zwrócenie tylko jednej pozycji naraz. Zbierasz wszystkie elementy na liście i ponownie zwracasz tę listę, co jest narzutem pamięci.