Qu'est-ce que la «rupture de rendement»; faire en C #?

J'ai vu cette syntaxe dans MSDN:, yield breakmais je ne sais pas ce qu'elle fait. Est-ce que quelqu'un sait?

Il spécifie qu'un itérateur a pris fin. Vous pouvez penser yield breakà une returndéclaration qui ne renvoie pas de valeur.

Par exemple, si vous définissez une fonction comme un itérateur, le corps de la fonction peut ressembler à ceci:

for (int i = 0; i < 5; i++)
{
    yield return i;
}

Console.Out.WriteLine("You will see me");

Notez qu'après que la boucle a terminé tous ses cycles, la dernière ligne est exécutée et vous verrez le message dans votre application console.

Ou comme ça avec 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");

Dans ce cas, la dernière instruction n'est jamais exécutée car nous avons quitté la fonction plus tôt.

Termine un bloc itérateur (par exemple, dit qu'il n'y a plus d'éléments dans l'IEnumerable).

Dit à l'itérateur qu'il est arrivé à la fin.

Par exemple:

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

yieldfait en sorte qu'une IEnumerable<T>méthode se comporte de manière similaire à un thread planifié en coopération (par opposition à préventivement).

yield returnest comme un thread appelant une fonction "Schedule" ou "Sleep" pour abandonner le contrôle du CPU. Tout comme un thread, la IEnumerable<T>méthode récupère les contrôles au point immédiatement après, toutes les variables locales ayant les mêmes valeurs qu'avant le abandon du contrôle.

yield break est comme un fil qui atteint la fin de sa fonction et se termine.

Les gens parlent d'une "machine d'état", mais une machine d'état n'est qu'un "fil". Un thread a un certain état (c'est-à-dire des valeurs de variables locales), et chaque fois qu'il est planifié, il prend une ou plusieurs actions afin d'atteindre un nouvel état. Le point clé à ce sujet yieldest que, contrairement aux threads du système d'exploitation auxquels nous sommes habitués, le code qui l'utilise est figé dans le temps jusqu'à ce que l'itération soit avancée ou terminée manuellement.

L'ensemble du sujet des blocs d'itérateur est bien couvert dans ce chapitre échantillon gratuit du livre de Jon Skeet C # en profondeur .

L' yield breakinstruction arrête l'énumération. En effet, yield breaktermine l'énumération sans retourner aucun élément supplémentaire.

Considérez qu'il existe en fait deux façons dont une méthode d'itérateur peut arrêter l'itération. Dans un cas, la logique de la méthode pourrait naturellement quitter la méthode après avoir renvoyé tous les éléments. Voici un exemple:

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

Dans l'exemple ci-dessus, la méthode itérateur arrêtera naturellement de s'exécuter une fois que les maxCountnombres premiers auront été trouvés.

L' yield breakinstruction est une autre façon pour l'itérateur de cesser d'énumérer. C'est un moyen de sortir tôt du dénombrement. Voici la même méthode que ci-dessus. Cette fois, la méthode a une limite sur la durée d'exécution de la méthode.

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

Remarquez l'appel à yield break. En effet, il quitte précocement l'énumération.

Remarquez également que les yield breaktravaux diffèrent d'une simple plaine break. Dans l'exemple ci-dessus, yield breakquitte la méthode sans appeler Debug.WriteLine(..).

Ici http://www.alteridem.net/2007/08/22/the-yield-statement-in-c/ est un très bon exemple:

public statique IEnumerable <int> Plage (int min, int max)
{
   tandis que (vrai)
   {
      si (min> = max)
      {
         rupture de rendement;
      }
      rendement retour min ++;
   }
}

et explication, que si une yield breakinstruction est frappée dans une méthode, l'exécution de cette méthode s'arrête sans retour. Il y a des situations temporelles, lorsque vous ne voulez pas donner de résultat, vous pouvez utiliser la rupture de rendement.

la rupture de rendement n'est qu'un moyen de dire retour pour la dernière fois et ne renvoie aucune valeur

par exemple

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

Si ce que vous entendez par «qu'est-ce que la rupture de rendement fait vraiment», c'est «comment ça marche» - Voir le blog de Raymond Chen pour plus de détails https://devblogs.microsoft.com/oldnewthing/20080812-00/?p=21273

Les itérateurs C # génèrent du code très compliqué.

Le mot clé yield est utilisé avec le mot clé return pour fournir une valeur à l'objet énumérateur. yield return spécifie la ou les valeurs renvoyées. Lorsque la déclaration de rendement est atteinte, l'emplacement actuel est stocké. L'exécution est redémarrée à partir de cet emplacement lors du prochain appel de l'itérateur.

Pour expliquer la signification à l'aide d'un exemple:

    public IEnumerable<int> SampleNumbers()
    {
        int counter = 0;
        yield return counter;

        counter = counter + 2;

        yield return counter;

        counter = counter + 3;

        yield return counter ;
    }

Les valeurs renvoyées lors de cette itération sont: 0, 2, 5.

Il est important de noter que la variable de compteur dans cet exemple est une variable locale. Après la deuxième itération qui retourne la valeur de 2, la troisième itération commence là où elle était avant, tout en conservant la valeur précédente de la variable locale nommée counter qui était 2.