unity que c# .net yield

que - ¿Qué hace “break de rendimiento”? ¿En C#?



yield return list c# (10)

He visto esta sintaxis en MSDN: corte de yield break , pero no sé qué hace. ¿Alguien sabe?

Aquí http://www.alteridem.net/2007/08/22/the-yield-statement-in-c/ es un buen ejemplo:

public static IEnumerable<int> Range( int min, int max ) { while ( true ) { if ( min >= max ) { yield break; } yield return min++; } }

y explicación, que si se golpea una declaración de yield break dentro de un método, la ejecución de ese método se detiene sin retorno. Hay algunas situaciones de tiempo, cuando no quieres dar ningún resultado, entonces puedes usar la ruptura del rendimiento.

Especifica que un iterador ha llegado a su fin. Puede pensar en la yield break del yield break como una declaración de return que no devuelve un valor.

Por ejemplo, si define una función como un iterador, el cuerpo de la función puede tener este aspecto:

for (int i = 0; i < 5; i++) { yield return i; } Console.Out.WriteLine("You will see me");

Tenga en cuenta que después de que el ciclo haya completado todos sus ciclos, la última línea se ejecutará y verá el mensaje en la aplicación de la consola.

O así, con el yield break :

int i = 0; while (true) { if (i < 5) { yield return i; } else { // note that i++ will not be executed after this yield break; } i++; } Console.Out.WriteLine("Won''t see me");

En este caso, la última instrucción nunca se ejecuta porque dejamos la función antes.

Finaliza un bloque de iteradores (p. Ej., Dice que no hay más elementos en IEnumerable).

La declaración de yield break hace que la enumeración se detenga En efecto, la yield break completa la enumeración sin devolver ningún elemento adicional.

Tenga en cuenta que en realidad hay dos formas en que un método iterador podría detener la iteración. En un caso, la lógica del método podría naturalmente salir del método después de devolver todos los elementos. Aquí hay un ejemplo:

IEnumerable<uint> FindPrimes(uint startAt, uint maxCount) { for (var i = 0UL; i < maxCount; i++) { startAt = NextPrime(startAt); yield return startAt; } Debug.WriteLine("All the primes were found."); }

En el ejemplo anterior, el método del iterador naturalmente dejará de ejecutarse una vez que se hayan encontrado los primos de maxCount .

La declaración de yield break es otra forma para que el iterador deje de enumerar. Es una forma de salir de la enumeración temprano. Aquí está el mismo método que el anterior. Esta vez, el método tiene un límite en la cantidad de tiempo que el método puede ejecutar.

IEnumerable<uint> FindPrimes(uint startAt, uint maxCount, int maxMinutes) { var sw = System.Diagnostics.Stopwatch.StartNew(); for (var i = 0UL; i < maxCount; i++) { startAt = NextPrime(startAt); yield return startAt; if (sw.Elapsed.TotalMinutes > maxMinutes) yield break; } Debug.WriteLine("All the primes were found."); }

Fíjate en la llamada a yield break . En efecto, está saliendo temprano de la enumeración.

Tenga en cuenta también que la diferencia de yield break funciona de forma diferente a una simple break . En el ejemplo anterior, el yield break sale del método sin realizar la llamada a Debug.WriteLine(..) .

La palabra clave de rendimiento se utiliza junto con la palabra clave return para proporcionar un valor al objeto del enumerador. rendimiento retorno especifica el valor, o valores, devueltos. Cuando se alcanza la declaración de rendimiento, se almacena la ubicación actual. La ejecución se reinicia desde esta ubicación la próxima vez que se llama al iterador.

Para explicar el significado usando un ejemplo:

public IEnumerable<int> SampleNumbers() { int counter = 0; yield return counter; counter = counter + 2; yield return counter; counter = counter + 3; yield return counter ; }

Los valores devueltos cuando se itera son: 0, 2, 5.

Es importante tener en cuenta que la variable de contador en este ejemplo es una variable local. Después de la segunda iteración que devuelve el valor de 2, la tercera iteración comienza desde donde se fue antes, mientras se conserva el valor anterior de la variable local denominada contador, que era 2.

Le dice al iterador que ha llegado al final.

Como ejemplo:

public interface INode { IEnumerable<Node> GetChildren(); } public class NodeWithTenChildren : INode { private Node[] m_children = new Node[10]; public IEnumerable<Node> GetChildren() { for( int n = 0; n < 10; ++n ) { yield return m_children[ n ]; } } } public class NodeWithNoChildren : INode { public IEnumerable<Node> GetChildren() { yield break; } }

la ruptura del rendimiento es solo una forma de decir devolución por última vez y no devolver ningún valor

p.ej

// returns 1,2,3,4,5 IEnumerable<int> CountToFive() { yield return 1; yield return 2; yield return 3; yield return 4; yield return 5; yield break; yield return 6; yield return 7; yield return 8; yield return 9; }

yield básicamente hace que un IEnumerable<T> se comporte de manera similar a un subproceso programado cooperativamente (en oposición a uno preventivo).

yield return es como un subproceso que llama a una función de "programación" o "suspensión" para ceder el control de la CPU. Al igual que un subproceso, el IEnumerable<T> recupera los controles en el punto inmediatamente posterior, y todas las variables locales tienen los mismos valores que tenían antes de abandonar el control.

yield break es como un hilo que llega al final de su función y termina.

La gente habla de una "máquina de estados", pero una máquina de estados es todo lo que realmente es un "hilo". Un subproceso tiene algún estado (es decir, valores de variables locales), y cada vez que se programa, realiza algunas acciones para alcanzar un nuevo estado. El punto clave sobre el yield es que, a diferencia de los subprocesos del sistema operativo al que estamos acostumbrados, el código que lo utiliza se congela a tiempo hasta que la iteración se avanza o finaliza manualmente.