¿Por qué usar la palabra clave yield, cuando podría usar unerableumerable ordinario?

El beneficio de los bloques iteradores es que funcionan perezosamente. Así que puedes escribir un método de filtrado como este:

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;
        }
    }
}

Eso le permitirá filtrar una secuencia el tiempo que desee, nunca almacenando en búfer más de un solo elemento a la vez. Si solo necesita el primer valor de la secuencia devuelta, por ejemplo, ¿por qué querría copiar todo en una nueva lista?

Como otro ejemplo, puede crear fácilmente un flujo infinito usando bloques iteradores. Por ejemplo, aquí hay una secuencia de números aleatorios:

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

¿Cómo almacenaría una secuencia infinita en una lista?

Mi Edulinq blog series da una implementación de ejemplo de LINQ a Objetos que hace pesado uso de bloques iteradores. LINQ es fundamentalmente perezoso donde puede ser , y poner las cosas en una lista simplemente no funciona de esa manera.

Con el código "list", debe procesar la lista completa antes de pasarla al siguiente paso. La versión "yield" pasa el elemento procesado inmediatamente al siguiente paso. Si ese "siguiente paso " contiene un".Take (10) "entonces la versión" yield " solo procesará los primeros 10 elementos y se olvidará del resto. El código de la "lista" habría procesado todo.

Esto significa que usted ve la mayor diferencia cuando necesita hacer mucho procesamiento y / o tener largas listas de elementos para proceso.

Puede usar yield para devolver elementos que no están en una lista. Aquí hay una pequeña muestra que podría iterar infinitamente a través de una lista hasta que se cancele.

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);
    }
}

Esto escribe

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

...sucesivamente. a la consola hasta que se cancele.

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

Cuando el código anterior se usa para recorrer FilteredList () y asumiendo item.Name = = "James" será satisfecho en el segundo ítem de la lista, el método usando yield dará dos veces. Este es un comportamiento perezoso.

Donde como el método que usa list agregará todos los n objetos a la lista y pasará la lista completa al método que llama.

Este es exactamente un caso de uso donde se puede resaltar la diferencia entre ILumerable e IList.

El mejor ejemplo del mundo real que he visto para el uso de yield sería calcular una secuencia de Fibonacci.

Considere el siguiente código:

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;
        }
    }
}

Esto volverá:

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

Esto es bueno porque le permite calcular una serie infinita rápida y fácilmente, dándole la capacidad de usar las extensiones Linq y consultar solo lo que necesita.

¿Por qué usar [yield]? Aparte de ser un poco menos de código, ¿qué hace por mí?

A veces es útil, a veces no. Si todo el conjunto de datos debe ser examinado y devuelto, entonces no va a haber ningún beneficio en el uso de rendimiento porque todo lo que hizo fue introducir gastos generales.

Cuando el rendimiento realmente brilla es cuando solo se devuelve un conjunto parcial. Creo que el mejor ejemplo es ordenar. Supongamos que tiene una lista de objetos que contienen una fecha y una cantidad en dólares de este año y le gustaría ver el primer puñado (5) registros del año.

Para lograr esto, la lista debe ordenarse ascendentemente por fecha, y luego tener los primeros 5 tomados. Si esto se hacía sin rendimiento, la lista completa tendría que ordenarse, hasta asegurarse de que las dos últimas fechas estuvieran en orden.

Sin embargo, con yield, una vez que se han establecido los primeros 5 elementos, la clasificación se detiene y los resultados están disponibles. Esto puede ahorrar una gran cantidad de tiempo.

La declaración yield return le permite devolver solo un artículo a la vez. Está recogiendo todos los elementos de una lista y devolviendo de nuevo esa lista, que es una sobrecarga de memoria.