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

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

Dans cet article, nous allons nous pencher sur le retour de rendement en C#, en explorant ses fonctionnalités, ses cas d'utilisation et la façon dont il peut transformer la façon dont vous abordez l'itération.

Comprendre les bases : L'itération en C# ;

L'itération est un concept fondamental en programmation, et C# propose différents mécanismes pour y parvenir. Traditionnellement, les boucles telles que for et foreach sont les outils les plus utilisés pour itérer sur des collections. Cependant, C# introduit 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 la déclaration de rendement

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

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

public IEnumerable<int> GenerateNumbers(int start, int end)
{
    // for loop goes through numbers, start to end
    for (int i = start; i <= end; i++) 
    {
        yield return i; // returns each number without breaking the loop
    }
}

// Usage
// foreach loop calls the previous function
foreach (var number in GenerateNumbers(1, 5)) 
{
    Console.WriteLine(number); // Outputs numbers 1 - 5
}

public IEnumerable<int> GenerateNumbers(int start, int end)
{
    // for loop goes through numbers, start to end
    for (int i = start; i <= end; i++) 
    {
        yield return i; // returns each number without breaking the loop
    }
}

// Usage
// foreach loop calls the previous function
foreach (var number in GenerateNumbers(1, 5)) 
{
    Console.WriteLine(number); // Outputs numbers 1 - 5
}

Public Iterator Function GenerateNumbers(ByVal start As Integer, ByVal [end] As Integer) As IEnumerable(Of Integer)
	' for loop goes through numbers, start to end
	For i As Integer = start To [end]
		Yield i ' returns each number without breaking the loop
	Next i
End Function

' Usage
' foreach loop calls the previous function
For Each number In GenerateNumbers(1, 5)
	Console.WriteLine(number) ' Outputs numbers 1 - 5
Next number

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

Évaluation paresseuse et efficacité

L'un des principaux avantages de l'instruction yield return est qu'elle permet une évaluation paresseuse. Contrairement aux méthodes traditionnelles qui génèrent une collection entière avant l'itération, yield return produit les valeurs une par une. Cela permet d'économiser de la mémoire, en particulier lorsqu'il s'agit de grands ensembles de données.

Itération avec état : Gérer des scénarios complexes

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

public IEnumerable<string> GenerateFibonacci(int count)
{
    int a = 0, b = 1;
    for (int i = 0; i < count; i++)
    {
        yield return a.ToString(); // returns 'a' value in the middle of the for loop
        int temp = a;
        a = b;
        b = temp + b;
    }
}
// Usage
// foreach loop that calls the previous iterator function
foreach (var fibNumber in GenerateFibonacci(8))
{
    Console.WriteLine(fibNumber); // Outputs a Fibonacci number sequence
}

public IEnumerable<string> GenerateFibonacci(int count)
{
    int a = 0, b = 1;
    for (int i = 0; i < count; i++)
    {
        yield return a.ToString(); // returns 'a' value in the middle of the for loop
        int temp = a;
        a = b;
        b = temp + b;
    }
}
// Usage
// foreach loop that calls the previous iterator function
foreach (var fibNumber in GenerateFibonacci(8))
{
    Console.WriteLine(fibNumber); // Outputs a Fibonacci number sequence
}

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 'a' value in the middle of the for loop
		Dim temp As Integer = a
		a = b
		b = temp + b
	Next i
End Function
' Usage
' foreach loop that calls the previous iterator function
For Each fibNumber In GenerateFibonacci(8)
	Console.WriteLine(fibNumber) ' Outputs a Fibonacci number sequence
Next fibNumber

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, ce qui garantit une génération et une sortie efficaces des nombres de Fibonacci.

Construire des séquences infinies

Une application intrigante du "rendement" est sa capacité à créer des séquences infinies de valeurs. Les valeurs étant générées à la volée, il est possible de représenter des séquences infinies sans consommer une mémoire infinie.

public IEnumerable<int> GenerateEvenNumbers()
{
    int num = 0;
    while (true)
    {
        yield return num;
        num += 2;
    }
}

// Usage
var evenNumberIterator = GenerateEvenNumbers().GetEnumerator();
for (int i = 0; i < 5; i++)
{
    evenNumberIterator.MoveNext();
    Console.WriteLine(evenNumberIterator.Current);
}

public IEnumerable<int> GenerateEvenNumbers()
{
    int num = 0;
    while (true)
    {
        yield return num;
        num += 2;
    }
}

// Usage
var evenNumberIterator = GenerateEvenNumbers().GetEnumerator();
for (int i = 0; i < 5; i++)
{
    evenNumberIterator.MoveNext();
    Console.WriteLine(evenNumberIterator.Current);
}

Public Iterator Function GenerateEvenNumbers() As IEnumerable(Of Integer)
	Dim num As Integer = 0
	Do
		Yield num
		num += 2
	Loop
End Function

' Usage
Private evenNumberIterator = GenerateEvenNumbers().GetEnumerator()
For i As Integer = 0 To 4
	evenNumberIterator.MoveNext()
	Console.WriteLine(evenNumberIterator.Current)
Next i

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

Présentation d'IronPDF : Une bibliothèque C# puissante

IronPDF est une bibliothèque C# polyvalente conçue pour simplifier les complexités du travail avec les PDF. Que vous produisiez des factures, des rapports ou tout autre document, IronPDF vous permet de convertir en toute transparence du contenu HTML en PDF professionnels et soignés, directement au sein de votre application C#.

Installation d'IronPDF : Un démarrage rapide

Pour intégrer IronPDF à votre projet C#, vous pouvez installer rapidement le paquet NuGet IronPDF. Exécutez la commande suivante dans la console du gestionnaire de paquets :

Installer le paquet IronPDF

Vous pouvez également localiser "IronPDF" dans le gestionnaire de paquets NuGet et l'installer à partir de là.

Générer des PDF avec IronPDF

La création d'un PDF à l'aide d'IronPDF est un processus simple. Prenons un exemple simple :

var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
// Create a new PDF document
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");

var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
// Create a new PDF document
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");

Dim htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
' Create a new PDF document
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf")

Dans l'exemple ci-dessus, IronPDF est utilisé pour rendreContenu HTML dans un document PDFqui est ensuite enregistré à l'emplacement spécifié. Pour de plus amples informations, veuillez consulter le siteDocumentation IronPDF.

L'intersection du "rendement" et de l'IronPDF

Voyons maintenant si l'instruction yield return, un outil puissant pour l'évaluation paresseuse et l'itération efficace, peut s'intégrer de manière transparente à IronPDF.

Considérons 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 exploiter les avantages des déclarations "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 à l'aide d'une instruction yield pour ajouter un contrôle dynamique sur le contenu du PDF :

class Program
{
    static void Main(string [] args)
    {
        public IEnumerable<string> GenerateDynamicContent()
        {
            yield return "Item 1";
            yield return "Item 2";
            yield return "Item 3";
        }

        // Usage
        var dynamicContent = GenerateDynamicContent();
        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 dynamicPdfDocument = new IronPdf.ChromePdfRenderer();
        dynamicPdfDocument.RenderHtmlAsPdf(dynamicPdfContent).SaveAs("C:/DynamicItems.pdf");
    }
}

class Program
{
    static void Main(string [] args)
    {
        public IEnumerable<string> GenerateDynamicContent()
        {
            yield return "Item 1";
            yield return "Item 2";
            yield return "Item 3";
        }

        // Usage
        var dynamicContent = GenerateDynamicContent();
        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 dynamicPdfDocument = new IronPdf.ChromePdfRenderer();
        dynamicPdfDocument.RenderHtmlAsPdf(dynamicPdfContent).SaveAs("C:/DynamicItems.pdf");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'		public IEnumerable(Of string) GenerateDynamicContent()
'		{
'			yield Return "Item 1";
'			yield Return "Item 2";
'			yield Return "Item 3";
'		}

		' Usage
		Dim dynamicContent = GenerateDynamicContent()
, 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 dynamicPdfDocument = New IronPdf.ChromePdfRenderer()
		dynamicPdfDocument.RenderHtmlAsPdf(dynamicPdfContent).SaveAs("C:/DynamicItems.pdf")
	End Sub
End Class

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.

Conclusion

En conclusion, yield return est une fonctionnalité puissante et élégante de C# qui transforme la façon dont vous abordez l'itération. Sa capacité à prendre en charge l'évaluation paresseuse, à gérer des scénarios complexes avec l'itération avec é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 que vous mettiez en œuvre des algorithmes sophistiqués, yield return vous permet d'écrire un code plus efficace et plus expressif.

Alors que le "retour sur investissement" facilite la génération efficace et à la demande de contenu, IronPDF intervient pour convertir de manière transparente ce contenu en documents PDF professionnels. Que vous créiez dynamiquement des listes, des rapports ou tout autre document, cette synergie vous permet de porter vos capacités de génération de documents C# à de nouveaux sommets. Exploitez le potentiel de ce duo dynamique et faites briller vos PDF grâce à un contenu dynamique et efficacement généré!

IronPDF fournit un service deessai gratuit pour tester l'ensemble de ses fonctionnalités, comme en mode commercial. En savoir plus surLicences IronPDF à partir de $749.