Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# Yield Return
.NET AIDE

C# Yield Return (Comment cela fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

C# est l'un des langages de programmation les plus populaires développés par Microsoft, qui offre des fonctionnalités ajoutant élégance et efficacité à votre code. L'une de ces fonctionnalités est le mot-clé yield, introduit pour la première fois dans C# 2.0. Microsoft fournit une référence linguistique complète sur les déclarations de mot-clé yield pour explorer plus en détail leur utilisation dans les méthodes d'itération, que vous pouvez consulter dans la documentation officielle de Microsoft sur yield.

Dans cet article, nous examinerons yield return en C#, explorant sa fonctionnalité, ses cas d'utilisation et comment il peut transformer votre approche de l'itération.

Comprendre les Bases : Itération en C#

L'itération est un concept fondamental en programmation, et C# offre divers mécanismes pour y parvenir. Traditionnellement, les boucles telles que la boucle for et la boucle foreach ont été les outils de prédilection pour itérer sur des collections. Cependant, C# propose une solution plus élégante avec le mot-clé yield appliqué à l'instruction return, et grâce à l'utilisation de l'interface IEnumerable.

L'efficacité de l'instruction yield return

Au fond, yield return est une instruction utilisée dans la méthode d'itérateur pour fournir un moyen plus efficace de générer une séquence de valeurs. Il vous permet de créer un itérateur sans avoir besoin de générer une collection entière en mémoire, ce qui est particulièrement utile pour les grands ensembles de données ou les séquences infinies.

Voici un exemple de code simple pour illustrer l'utilisation de base de yield return :

using System;
using System.Collections.Generic;

public class Example
{
    // Method that generates numbers from start to end using 'yield return'
    public IEnumerable<int> GenerateNumbers(int start, int end)
    {
        // Loop from 'start' to 'end'
        for (int i = start; i <= end; i++)
        {
            yield return i; // Returns each number in the sequence without breaking the loop
        }
    }

    public static void Main()
    {
        // Usage: Using 'foreach' to iterate over numbers generated by 'GenerateNumbers'
        foreach (var number in new Example().GenerateNumbers(1, 5))
        {
            Console.WriteLine(number); // Outputs numbers 1 - 5
        }
    }
}
using System;
using System.Collections.Generic;

public class Example
{
    // Method that generates numbers from start to end using 'yield return'
    public IEnumerable<int> GenerateNumbers(int start, int end)
    {
        // Loop from 'start' to 'end'
        for (int i = start; i <= end; i++)
        {
            yield return i; // Returns each number in the sequence without breaking the loop
        }
    }

    public static void Main()
    {
        // Usage: Using 'foreach' to iterate over numbers generated by 'GenerateNumbers'
        foreach (var number in new Example().GenerateNumbers(1, 5))
        {
            Console.WriteLine(number); // Outputs numbers 1 - 5
        }
    }
}
Imports System
Imports System.Collections.Generic

Public Class Example
	' Method that generates numbers from start to end using 'yield return'
	Public Iterator Function GenerateNumbers(ByVal start As Integer, ByVal [end] As Integer) As IEnumerable(Of Integer)
		' Loop from 'start' to 'end'
		For i As Integer = start To [end]
			Yield i ' Returns each number in the sequence without breaking the loop
		Next i
	End Function

	Public Shared Sub Main()
		' Usage: Using 'foreach' to iterate over numbers generated by 'GenerateNumbers'
		For Each number In (New Example()).GenerateNumbers(1, 5)
			Console.WriteLine(number) ' Outputs numbers 1 - 5
		Next number
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, la méthode GenerateNumbers utilise yield return pour produire une séquence de nombres de start à end. L'itérateur est évalué paresseusement, ce qui signifie que chaque numéro est généré à la demande pendant l'exécution de l'itération.

Évaluation Paresseuse et Efficacité

Un des avantages significatifs de l'instruction yield return est sa capacité à prendre en charge l'évaluation paresseuse. Contrairement aux méthodes traditionnelles qui génèrent une collection entière avant l'itération, yield return produit des valeurs une par une. Cela peut entraîner des économies de mémoire importantes, en particulier lors de la gestion de grands ensembles de données.

Itération Avec État : Gérer des Scénarios Complexes

L'instruction yield return n'est pas limitée à la génération de séquences simples; elle excelle dans la gestion de scénarios plus complexes dans le bloc d'itérateur. En maintenant une machine d'état à travers les itérations, vous pouvez créer des itérateurs qui se souviennent de leur position dans la séquence.

using System;
using System.Collections.Generic;

public class FibonacciExample
{
    // Method that generates Fibonacci numbers up to the specified count
    public IEnumerable<string> GenerateFibonacci(int count)
    {
        int a = 0, b = 1;
        for (int i = 0; i < count; i++)
        {
            yield return a.ToString(); // Returns the Fibonacci number as a string
            int temp = a;
            a = b;
            b = temp + b;
        }
    }

    public static void Main()
    {
        // Usage: Iterating over Fibonacci numbers generated by 'GenerateFibonacci'
        foreach (var fibNumber in new FibonacciExample().GenerateFibonacci(8))
        {
            Console.WriteLine(fibNumber); // Outputs a Fibonacci number sequence
        }
    }
}
using System;
using System.Collections.Generic;

public class FibonacciExample
{
    // Method that generates Fibonacci numbers up to the specified count
    public IEnumerable<string> GenerateFibonacci(int count)
    {
        int a = 0, b = 1;
        for (int i = 0; i < count; i++)
        {
            yield return a.ToString(); // Returns the Fibonacci number as a string
            int temp = a;
            a = b;
            b = temp + b;
        }
    }

    public static void Main()
    {
        // Usage: Iterating over Fibonacci numbers generated by 'GenerateFibonacci'
        foreach (var fibNumber in new FibonacciExample().GenerateFibonacci(8))
        {
            Console.WriteLine(fibNumber); // Outputs a Fibonacci number sequence
        }
    }
}
Imports System
Imports System.Collections.Generic

Public Class FibonacciExample
	' Method that generates Fibonacci numbers up to the specified count
	Public Iterator Function GenerateFibonacci(ByVal count As Integer) As IEnumerable(Of String)
		Dim a As Integer = 0, b As Integer = 1
		For i As Integer = 0 To count - 1
			Yield a.ToString() ' Returns the Fibonacci number as a string
			Dim temp As Integer = a
			a = b
			b = temp + b
		Next i
	End Function

	Public Shared Sub Main()
		' Usage: Iterating over Fibonacci numbers generated by 'GenerateFibonacci'
		For Each fibNumber In (New FibonacciExample()).GenerateFibonacci(8)
			Console.WriteLine(fibNumber) ' Outputs a Fibonacci number sequence
		Next fibNumber
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, la méthode GenerateFibonacci utilise yield return pour créer une séquence de nombres de Fibonacci. L'état est maintenu entre les itérations, assurant une génération et une sortie efficaces des nombres de Fibonacci.

Construire des Séquences Infinies

Une application intrigante de yield return est sa capacité à créer des séquences infinies de valeurs. Étant donné que les valeurs sont générées à la volée, vous pouvez représenter des séquences qui continuent indéfiniment sans consommer une mémoire infinie.

using System;
using System.Collections.Generic;

public class InfiniteSequenceExample
{
    // Method that generates an infinite sequence of even numbers
    public IEnumerable<int> GenerateEvenNumbers()
    {
        int num = 0;
        while (true)
        {
            yield return num;
            num += 2;
        }
    }

    public static void Main()
    {
        // Usage: Generating even numbers using the 'GenerateEvenNumbers' method
        var evenNumberIterator = new InfiniteSequenceExample().GenerateEvenNumbers().GetEnumerator();
        for (int i = 0; i < 5; i++)
        {
            evenNumberIterator.MoveNext();
            Console.WriteLine(evenNumberIterator.Current); // Outputs the first 5 even numbers
        }
    }
}
using System;
using System.Collections.Generic;

public class InfiniteSequenceExample
{
    // Method that generates an infinite sequence of even numbers
    public IEnumerable<int> GenerateEvenNumbers()
    {
        int num = 0;
        while (true)
        {
            yield return num;
            num += 2;
        }
    }

    public static void Main()
    {
        // Usage: Generating even numbers using the 'GenerateEvenNumbers' method
        var evenNumberIterator = new InfiniteSequenceExample().GenerateEvenNumbers().GetEnumerator();
        for (int i = 0; i < 5; i++)
        {
            evenNumberIterator.MoveNext();
            Console.WriteLine(evenNumberIterator.Current); // Outputs the first 5 even numbers
        }
    }
}
Imports System
Imports System.Collections.Generic

Public Class InfiniteSequenceExample
	' Method that generates an infinite sequence of even numbers
	Public Iterator Function GenerateEvenNumbers() As IEnumerable(Of Integer)
		Dim num As Integer = 0
		Do
			Yield num
			num += 2
		Loop
	End Function

	Public Shared Sub Main()
		' Usage: Generating even numbers using the 'GenerateEvenNumbers' method
		Dim evenNumberIterator = (New InfiniteSequenceExample()).GenerateEvenNumbers().GetEnumerator()
		For i As Integer = 0 To 4
			evenNumberIterator.MoveNext()
			Console.WriteLine(evenNumberIterator.Current) ' Outputs the first 5 even numbers
		Next i
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, la méthode GenerateEvenNumbers crée un itérateur pour les nombres pairs, et vous pouvez y itérer selon vos besoins. Vous pouvez également utiliser l'instruction yield break avec yield return pour arrêter et sortir de la boucle, créant une itération personnalisée pour la boucle.

Présentation d'IronPDF : Une Bibliothèque C# Puissante

C# Yield Return (Comment cela fonctionne pour les développeurs) : Figure 1 - page Web IronPDF

IronPDF se distingue comme une bibliothèque C# polyvalente conçue pour simplifier la complexité du travail avec les PDF. Que vous génériez des factures, des rapports ou tout autre document, IronPDF vous permet de convertir sans effort le contenu HTML en PDF soignés et professionnels directement dans votre application C#.

Installer IronPDF : Un démarrage rapide

Pour intégrer IronPDF dans votre projet C#, vous pouvez rapidement installer le package NuGet IronPDF. Exécutez la commande suivante dans votre Console du Gestionnaire de Packages :

Install-Package IronPdf

Alternativement, vous pouvez localiser "IronPDF" dans le gestionnaire de packages NuGet et l'installer à partir de là.

Générer des PDFs avec IronPDF

Créer un PDF à l'aide d'IronPDF est un processus simple. Considérons un exemple de base :

using IronPdf;

public class PdfGenerationExample
{
    public static void Main()
    {
        var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";

        // Create a new PDF renderer instance
        var pdfRenderer = new ChromePdfRenderer();

        // Render the HTML content as a PDF and save it to a file
        pdfRenderer.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");
    }
}
using IronPdf;

public class PdfGenerationExample
{
    public static void Main()
    {
        var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";

        // Create a new PDF renderer instance
        var pdfRenderer = new ChromePdfRenderer();

        // Render the HTML content as a PDF and save it to a file
        pdfRenderer.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");
    }
}
Imports IronPdf

Public Class PdfGenerationExample
	Public Shared Sub Main()
		Dim htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>"

		' Create a new PDF renderer instance
		Dim pdfRenderer = New ChromePdfRenderer()

		' Render the HTML content as a PDF and save it to a file
		pdfRenderer.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans l'exemple ci-dessus, IronPDF est utilisé pour rendre le contenu HTML dans un document PDF, qui est ensuite enregistré à l'emplacement spécifié. Pour plus d'informations détaillées, veuillez visiter la documentation IronPDF.

L'Intersection de yield return et IronPDF

Maintenant, explorons si l'instruction yield return, un outil puissant pour l'évaluation paresseuse et l'itération efficace, peut s'intégrer sans problème avec IronPDF.

Considérez un scénario dans lequel vous devez générer un document PDF avec une liste d'éléments en utilisant yield return. Vous pouvez tirer parti des avantages des instructions yield pour générer dynamiquement du contenu, puis utiliser IronPDF pour transformer ce contenu en PDF. L'extrait de code suivant génère un document PDF avec l'aide d'une instruction yield pour ajouter un contrôle dynamique au contenu PDF :

using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;

class Program
{
    // Method that dynamically generates content using 'yield return'
    public static IEnumerable<string> GenerateDynamicContent()
    {
        yield return "Item 1";
        yield return "Item 2";
        yield return "Item 3";
    }

    public static void Main(string[] args)
    {
        // Generate dynamic content using the 'GenerateDynamicContent' function
        var dynamicContent = GenerateDynamicContent();

        // Create HTML structure for the PDF document with dynamic content
        var dynamicPdfContent = $@"
            <html>
            <body>
                <h1>List of Items</h1>
                <ul>
                    {string.Join("", dynamicContent.Select(item => $"<li>{item}</li>"))}
                </ul>
            </body>
            </html>
        ";

        // Create a new PDF document with dynamically generated content
        var dynamicPdfRenderer = new ChromePdfRenderer();
        dynamicPdfRenderer.RenderHtmlAsPdf(dynamicPdfContent).SaveAs("C:/DynamicItems.pdf");
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;

class Program
{
    // Method that dynamically generates content using 'yield return'
    public static IEnumerable<string> GenerateDynamicContent()
    {
        yield return "Item 1";
        yield return "Item 2";
        yield return "Item 3";
    }

    public static void Main(string[] args)
    {
        // Generate dynamic content using the 'GenerateDynamicContent' function
        var dynamicContent = GenerateDynamicContent();

        // Create HTML structure for the PDF document with dynamic content
        var dynamicPdfContent = $@"
            <html>
            <body>
                <h1>List of Items</h1>
                <ul>
                    {string.Join("", dynamicContent.Select(item => $"<li>{item}</li>"))}
                </ul>
            </body>
            </html>
        ";

        // Create a new PDF document with dynamically generated content
        var dynamicPdfRenderer = new ChromePdfRenderer();
        dynamicPdfRenderer.RenderHtmlAsPdf(dynamicPdfContent).SaveAs("C:/DynamicItems.pdf");
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports IronPdf

Friend Class Program
	' Method that dynamically generates content using 'yield return'
	Public Shared Iterator Function GenerateDynamicContent() As IEnumerable(Of String)
		Yield "Item 1"
		Yield "Item 2"
		Yield "Item 3"
	End Function

	Public Shared Sub Main(ByVal args() As String)
		' Generate dynamic content using the 'GenerateDynamicContent' function
		Dim dynamicContent = GenerateDynamicContent()

		' Create HTML structure for the PDF document with dynamic content
, String.Join(TangibleTempVerbatstring.Format(mDoubleQuote, dynamicContent.Select(Function(item) $TangibleTempVerbatimCloseTag"<li>{item}</li>")), TangibleStringInterpolationMarker) var dynamicPdfContent = $"TangibleTempVerbatimOpenTagTangibleTempVerbatimStringLiteralLineJoin            <html>TangibleTempVerbatimStringLiteralLineJoin            <body>TangibleTempVerbatimStringLiteralLineJoin                <h1>List of Items</h1>TangibleTempVerbatimStringLiteralLineJoin                <ul>TangibleTempVerbatimStringLiteralLineJoin                    {0}ignoreignoreignoreignoreignore</ul></body></html>"

		' Create a new PDF document with dynamically generated content
		Dim dynamicPdfRenderer = New ChromePdfRenderer()
		dynamicPdfRenderer.RenderHtmlAsPdf(dynamicPdfContent).SaveAs("C:/DynamicItems.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, la méthode GenerateDynamicContent utilise yield return pour fournir une séquence d'éléments dynamiques. Le contenu généré est ensuite incorporé dans une structure HTML et utilisé par IronPDF pour créer un document PDF.

C# Yield Return (Comment cela fonctionne pour les développeurs) : Figure 2 - Sortie PDF du code précédent

Conclusion

En conclusion, yield return est une fonctionnalité puissante et élégante en C# qui transforme votre approche de l'itération. Sa capacité à prendre en charge l'évaluation paresseuse, à gérer des scénarios complexes avec une itération à état et à créer des séquences infinies en fait un outil précieux dans votre boîte à outils de programmation. Que vous traitiez de grands ensembles de données ou mettiez en œuvre des algorithmes sophistiqués, yield return vous permet d'écrire du code plus efficace et expressif.

Tandis que yield return facilite la génération efficace et à la demande de contenu, IronPDF intervient pour convertir ce contenu en documents PDF professionnels. Que vous créiez dynamiquement des listes, des rapports ou tout autre document, cette synergie vous permet d'amener vos capacités de génération de documents C# à de nouveaux sommets. Exploitez le potentiel de ce duo dynamique, et laissez vos PDF briller avec un contenu dynamique et généré efficacement !

IronPDF offre un essai gratuit pour tester sa fonctionnalité complète comme en mode commercial. En savoir plus sur les licences IronPDF à partir de $799.

Questions Fréquemment Posées

Comment puis-je utiliser l'instruction yield return pour améliorer l'itération en C#?

L'instruction yield return peut être utilisée en C# pour générer des séquences efficacement. Elle permet la création d'itérateurs qui produisent des valeurs à la demande, ce qui permet d'économiser de la mémoire en n'exigeant pas le stockage d'une collection entière.

Quels avantages yield return offre-t-il lors du travail avec de grands ensembles de données?

Yield return offre l'avantage de l'évaluation paresseuse, ce qui signifie que les valeurs sont générées uniquement selon le besoin. Cela réduit significativement l'utilisation de la mémoire lorsque l'on traite de grands ensembles de données, car la séquence complète n'a pas besoin d'être stockée en mémoire.

Yield return peut-il être utilisé en conjonction avec la génération de PDF en C#?

Oui, yield return peut être utilisé pour générer dynamiquement du contenu qui peut ensuite être converti en format PDF en utilisant IronPDF. Cette approche facilite la génération efficace et dynamique de documents au sein des applications C#.

Comment yield return simplifie-t-il la création de séquences infinies en C#?

Yield return simplifie la création de séquences infinies en générant des valeurs à la volée. Cela signifie qu'il peut continuer à produire indéfiniment des valeurs sans épuiser la mémoire, car il ne crée chaque élément que lorsqu'il est nécessaire.

Quel est le bénéfice de l'évaluation paresseuse dans le contexte de la programmation en C#?

En C#, l'évaluation paresseuse, facilitée par yield return, permet aux valeurs d'être calculées uniquement au fur et à mesure de leur nécessité lors du processus d'itération. Cela conduit à une utilisation plus efficace de la mémoire et peut améliorer les performances lorsqu'on gère des séquences de données étendues ou complexes.

Comment puis-je convertir du contenu HTML en PDF en utilisant une bibliothèque C#?

Vous pouvez convertir du contenu HTML en PDF en C# en utilisant la bibliothèque IronPDF. La bibliothèque ChromePdfRenderer peut rendre HTML et CSS en documents PDF de qualité professionnelle.

Quel est un cas d'utilisation pratique de yield return avec IronPDF?

Un cas d'utilisation pratique est la génération dynamique de données de rapport avec yield return, suivie de la conversion de ces données en PDF en utilisant IronPDF. Cette méthode est efficace pour créer des documents dynamiques sans pré-générer tout le contenu en mémoire.

Quels sont les principaux avantages de l'utilisation de yield return en C# pour les développeurs?

Yield return offre plusieurs avantages, y compris une meilleure efficacité mémoire grâce à l'évaluation paresseuse, la capacité à gérer des scénarios d'itération complexes, et la possibilité de générer des séquences infinies sans débordement de mémoire.

Comment installer une bibliothèque C# pour la manipulation PDF?

Pour installer une bibliothèque comme IronPDF pour la manipulation de PDF dans un projet C#, vous pouvez utiliser le gestionnaire de packages NuGet avec la commande : Install-Package IronPDF.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit