Intro to Yield in C# - Qu'est-ce que c'est, comment l'utiliser et quand est-ce utile ?

Introduction au mot-clé Yield en C

Tim commence par présenter le mot-clé yield et souligne qu'il peut souvent être source de confusion pour les développeurs qui le rencontrent pour la première fois. Il explique que l'instruction yield permet à une méthode d'interrompre son exécution, de conserver son état et de reprendre là où elle s'est arrêtée lors du prochain appel. Tim souligne qu'il est essentiel de comprendre le rendement pour traiter efficacement les données, en particulier lorsqu'il s'agit de grands ensembles de données ou de la mise en œuvre d'une logique d'itération personnalisée.

Mise en place d'un exemple simple : Programme de classe et Void statique Main

Pour éliminer les distractions, Tim crée une simple application console dans Visual Studio, appelée "YieldDemoApp"

Ce que Yield fait réellement en C

Tim approfondit ensuite la théorie. À 2:04, il décrit le comportement de yield : Au lieu de traiter une collection entière en une seule fois, l'instruction yield retient un point - comme on met un pouce dans un livre - afin que l'exécution puisse s'interrompre et reprendre plus tard.

Ce comportement est crucial pour l'exécution différée, où les valeurs ne sont générées qu'en cas de besoin, plutôt que de tout calculer à l'avance. La description de Tim pose clairement les bases pour comprendre le fonctionnement du retour sur investissement.

Écrire un code de démonstration

Dans la méthode statique void Main de la classe Program, il met en place des messages de base comme "Start of the app" et "End of the app" à l'aide de Console.WriteLine, ce qui permet de visualiser clairement le flux lors de l'utilisation ultérieure d'une boucle foreach.

Cet exemple de code initial se concentre uniquement sur l'implémentation du rendement sans impliquer aucune complexité d'interface utilisateur.

Création de la classe PersonModel

Pour la démonstration, Tim crée une classe PersonModel avec des propriétés FirstName et LastName et un constructeur. Lorsqu'un objet PersonModel est créé, un message est imprimé, indiquant quel utilisateur a été initialisé. Cela permet de visualiser le moment où les objets sont créés et le moment où ils sont consommés.

Cette simple étape de génération de code prépare le terrain pour travailler avec des itérateurs personnalisés.

Construction de la classe DataAccess avec un retour de liste traditionnel

À 5:06, Tim passe à une classe DataAccess avec une méthode GetPeople renvoyant IEnumerable. Initialement, la valeur de retour est une liste remplie de trois instances de PersonModel : Tim Corey, Sue Storm et Jane Smith.

Cette méthode iterator charge tous les objets immédiatement en mémoire avant le début de l'itération - un point important que Tim oppose ensuite à l'utilisation de yield.

Démonstration de l'utilisation de la mémoire avec List

Après avoir exécuté la boucle foreach, Tim montre que les trois utilisateurs sont créés avant même que le premier élément ne soit lu. La traduction doit rester professionnelle et préserver la précision technique tout en expliquant les caractéristiques et les avantages de ces outils de développement.

Tim explique que si nous avions, disons, un millier d'utilisateurs, nous aurions créé un millier d'objets même si nous n'en avions besoin que de quelques-uns, ce qui aurait entraîné une allocation de mémoire inefficace.

Changement vers Yield Return for Deferred Execution (Rendement pour exécution différée)

À 10:01, Tim modifie GetPeople pour utiliser le retour de rendement au lieu de créer une collection temporaire (une liste). Chaque instruction yield return émet directement un PersonModel à la fois.

Ce code critique à l'intérieur de la méthode permet une évaluation paresseuse, où l'élément suivant n'est généré que lorsque le foreach en a besoin.

Tim précise également que le type de retour de la méthode doit être IEnumerable et que l'utilisation de List irait à l'encontre de l'objectif de l'exécution différée.

Débogage : Comment le compilateur génère du code pour le rendement

Tim utilise des points d'arrêt pour avancer dans le processus. Il montre qu'avant le premier appel à MoveNext, la séquence est vide. Ce n'est que lorsque foreach a besoin de la valeur suivante que le compilateur déclenche le bloc itérateur et exécute la ligne yield return num, qui initialise et renvoie le PersonModel.

Tim souligne que le compilateur génère des machines d'état spéciales sous le capot pour gérer l'exécution en pause et la reprise.

Avantages et efficacité de l'utilisation de Yield Return

Tim explique pourquoi le rendement est si efficace :

• Vous ne pouvez récupérer qu'un seul enregistrement à la fois.

• Vous pouvez limiter le nombre d'int dont vous avez besoin.

• Vous évitez de charger l'ensemble de la collection en mémoire.

• Vous améliorez l'évolutivité, en particulier lorsque vous travaillez avec des fichiers volumineux ou des flux de données.

En utilisant .Take(2) de LINQ, Tim démontre que seuls deux objets sont initialisés malgré l'existence de trois déclarations de retour - ce qui met en évidence l'exécution différée en action.

Exemple pratique : Générateur de nombres premiers utilisant Yield

Tim crée une nouvelle méthode statique IEnumerable GetPrimeNumbers() dans une classe Generators. Dans cette boucle infinie, Tim utilise la fonction IsPrimeNumber(int number) pour vérifier la primalité. Si le nombre est premier, il utilise le numéro de retour de rendement pour l'émettre.

Cet exemple montre que le rendement est essentiel pour traiter les séquences infinies en toute sécurité.

Sans rendement, le code se bloquerait en raison d'une consommation de mémoire illimitée. En utilisant le rendement, cependant, l'exécution différée garantit que les nombres sont générés à la demande.

Récupération des nombres premiers avec Take()

Tim montre ensuite comment récupérer en toute sécurité un nombre fixe de nombres premiers :

var primeNumbers = Generators.GetPrimeNumbers().Take(10000);

var primeNumbers = Generators.GetPrimeNumbers().Take(10000);

Ce code écrit à l'intérieur de static void Main permet de récupérer efficacement 10 000 nombres premiers.

Comme yield return produit les chiffres un par un, l'utilisation de la mémoire reste faible.

Itération personnalisée : Utilisation de GetEnumerator et MoveNext

Tim va plus loin en expliquant comment contrôler manuellement l'itération.

Il crée un var iterator = primeNumbers.GetEnumerator(), puis utilise une boucle for avec int i et appelle iterator.MoveNext() pour récupérer les éléments manuellement.

Cette approche manuelle permet une itération personnalisée - en demandant la valeur suivante uniquement lorsque cela est nécessaire, et en montrant que la méthode reprend exactement là où elle s'est arrêtée la dernière fois.

Une erreur courante : L'utilisation de ToList() sur des collections cédées

À 36:45, Tim met en garde : la conversion d'une séquence de rendement en une liste avec .ToList() entraîne une évaluation complète immédiate.

Si vous appelez .ToList() sur une séquence infinie, vous risquez de faire planter votre application.

Tim souligne que le retour de rendement est destiné à une évaluation paresseuse et que l'appel à .ToList() rompt avec ce modèle en forçant la matérialisation complète de la mémoire.

Lorsque vous travaillez avec des méthodes LINQ, Tim recommande de faire attention à l'endroit où vous introduisez .ToList().

Résumé : Pourquoi Yield est un outil puissant

Tim conclut en rappelant que si le mot-clé yield ajoute une légère surcharge (maintien d'une machine d'état), les avantages de l'utilisation réduite de la mémoire et de l'évaluation paresseuse en font un outil puissant lorsqu'on travaille avec :

• Grands ensembles de données

• Fichiers volumineux

• Itérateurs personnalisés

• Séquences infinies

• Flux de données

• Traitement différé

Il suggère de s'entraîner avec le rendement dans différents projets pour développer une compréhension plus profonde du rendement et éviter les pièges les plus courants.

Tim conclut en invitant les spectateurs à partager la façon dont ils ont utilisé yield dans le code de production.

Conclusion

En parcourant la vidéo de Tim Corey, nous avons pu constater les immenses avantages que le mot-clé yield apporte au langage C#. De la création d'itérateurs personnalisés à la gestion efficace de grandes collections, yield return permet aux retours de fonctions d'être plus intelligents et plus efficaces en termes de mémoire. Que vous travailliez avec var number, var point, var reader, var connection, ou de grands ensembles de données, la maîtrise de yield peut élever vos compétences de codage C# de façon spectaculaire.

Si vous n'avez pas encore exploré l'utilisation de yield, c'est le moment idéal pour vous y exercer à travers des exemples simples et mieux comprendre le fonctionnement du retour de yield à l'intérieur du compilateur C#. Consultez la chaîne YouTube officielle de Tim, YouTube Channel, pour découvrir d'autres vidéos intéressantes.