Boucle for en C# (Comment ça fonctionne pour les développeurs)

Commencer avec les boucles for

Une boucle for est un type de boucle en C#, spécialement conçue pour les situations où vous savez exactement combien de fois vous voulez itérer. La syntaxe d'une boucle for en C# est illustrée dans le bloc de code ci-dessous :

for (initialization; condition; increment)
{
    // Loop body
}

for (initialization; condition; increment)
{
    // Loop body
}

initialization
Do While condition
	' Loop body
	increment
Loop

Analysons les composants d'une boucle for :

1. Initialisation : C'est ici que la variable de boucle, ou variable d'itération, est déclarée et initialisée.
2. Condition : Une expression booléenne/conditionnelle qui détermine si la boucle doit continuer à exécuter les instructions plusieurs fois ou non.
3. Incrémentation : Cette instruction met à jour la variable d'itération après chaque itération.

Static void Main et variables de boucle

En C#, la méthode static void Main ou static void Main(String []args) est le point d'entrée de votre application. C'est à cet endroit que votre programme commence à s'exécuter. Voici un exemple de boucle for à l'intérieur de la méthode static void Main :

using System;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("This is the first for loop!");
        }
    }
}

using System;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("This is the first for loop!");
        }
    }
}

Imports System

Friend Class Program
	Shared Sub Main()
		For i As Integer = 0 To 4
			Console.WriteLine("This is the first for loop!")
		Next i
	End Sub
End Class

Dans cet exemple, la variable de boucle int i est initialisée à 0 et agit comme la variable. La boucle continuera à s'exécuter tant que i est inférieur à 5. Après chaque itération, l'opération d'incrémentation i++ augmente la valeur de i de 1.

Explorer les boucles imbriquées

Les boucles imbriquées sont des boucles placées à l'intérieur d'autres boucles, formant une boucle interne et une boucle externe avec des sections itératives. Celles-ci peuvent être utiles lorsque vous travaillez avec des structures de données multidimensionnelles comme des matrices ou lorsque vous devez effectuer une certaine opération sur chaque combinaison d'éléments.

Voici un exemple d'une boucle for imbriquée avec une boucle interne à l'intérieur d'une boucle externe en C# :

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 2; j++)
    {
        Console.WriteLine($"i: {i}, j: {j}");
    }
}

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 2; j++)
    {
        Console.WriteLine($"i: {i}, j: {j}");
    }
}

For i As Integer = 0 To 2
	For j As Integer = 0 To 1
		Console.WriteLine($"i: {i}, j: {j}")
	Next j
Next i

Dans cet exemple, la boucle externe s'exécute et commence avec i égal à 0. La boucle interne parcourt ensuite toutes les valeurs possibles de j avant de passer à la valeur suivante de i.

Boucles infinies et contrôle des boucles

Une boucle infinie est une boucle qui ne se termine jamais car sa condition de test ne devient jamais fausse. Celles-ci peuvent être dangereuses, car elles peuvent empêcher votre programme de fonctionner indéfiniment. Soyez prudent lorsque vous écrivez des boucles telles que des boucles while ou des boucles foreach pour vous assurer que la condition de sortie sera finalement remplie. Voici un exemple d'une boucle infinie sans condition spécifiée en C#.

// This is an example of an infinite loop
for (int i = 0; ; i++)
{
    Console.WriteLine("This loop will run forever!");
}

// This is an example of an infinite loop
for (int i = 0; ; i++)
{
    Console.WriteLine("This loop will run forever!");
}

' This is an example of an infinite loop
Dim i As Integer = 0
Do
	Console.WriteLine("This loop will run forever!")
	i += 1
Loop

En plus de la structure de boucle standard for, C# fournit également des instructions de contrôle de boucle, telles que break et continue, qui peuvent vous aider à gérer vos boucles plus efficacement.

• break : Cette instruction permet de sortir immédiatement de la boucle. Lorsqu'une instruction break est rencontrée, la boucle s'arrête et le programme poursuit son exécution avec la ligne de code suivante, en dehors de la boucle.
• continue: Cette instruction est utilisée pour ignorer le reste du code dans le corps de la boucle pour l'itération actuelle et passer à l'itération suivante de la boucle.

Voici un exemple illustrant l'utilisation de break et continue dans une boucle for :

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break; // Exits the loop when i is equal to 5
    }

    if (i % 2 == 0)
    {
        continue; // Skips even numbers
    }

    Console.WriteLine($"Odd number: {i}");
}

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break; // Exits the loop when i is equal to 5
    }

    if (i % 2 == 0)
    {
        continue; // Skips even numbers
    }

    Console.WriteLine($"Odd number: {i}");
}

For i As Integer = 0 To 9
	If i = 5 Then
		Exit For ' Exits the loop when i is equal to 5
	End If

	If i Mod 2 = 0 Then
		Continue For ' Skips even numbers
	End If

	Console.WriteLine($"Odd number: {i}")
Next i

Dans cet exemple, la boucle cesse de s'exécuter lorsque i atteint 5. L'instruction continue est utilisée pour ignorer les nombres pairs, de sorte que seuls les nombres impairs inférieurs à 5 seront imprimés.

Expressions booléennes et conditions de boucle

La condition de boucle est une expression booléenne qui détermine si la boucle doit continuer à s'exécuter. Cette expression est évaluée avant chaque itération, et la boucle ne s'exécutera que si l'expression est true. Les expressions booléennes couramment utilisées dans de nombreuses boucles incluent :

• Comparaisons : i < 10 , i >= 10 , i > 10 , i == 10 , i != 10
• Opérateurs logiques : && (ET), || (OR), ! (PAS)

Vous pouvez combiner plusieurs expressions à l'aide d'opérateurs logiques pour créer des conditions de boucle plus complexes. Par exemple :

for (int i = 0; i < 10 && i != 5; i++)
{
    Console.WriteLine(i);
}

for (int i = 0; i < 10 && i != 5; i++)
{
    Console.WriteLine(i);
}

Dim i As Integer = 0
Do While i < 10 AndAlso i <> 5
	Console.WriteLine(i)
	i += 1
Loop

Dans cet exemple, la boucle s'exécutera tant que i est inférieur à 10 et différent de 5 .

Blocs de code et corps de boucle

Un bloc de code est un groupe d'instructions entourées d'accolades {}. Dans une boucle for, le bloc de code qui suit la déclaration de la boucle est connu sous le nom de corps de boucle. C'est là que vous placerez le code que vous souhaitez exécuter à chaque itération de la boucle.

for (int i = 0; i < 5; i++)
{
    // This is the loop body
    Console.WriteLine($"Iteration: {i}");
}

for (int i = 0; i < 5; i++)
{
    // This is the loop body
    Console.WriteLine($"Iteration: {i}");
}

For i As Integer = 0 To 4
	' This is the loop body
	Console.WriteLine($"Iteration: {i}")
Next i

Dans cet exemple, le corps de la boucle se compose d'une seule instruction Console.WriteLine qui imprime le numéro d'itération actuel.

Étapes d'Exécution d'une Boucle

Lorsqu'une boucle for est rencontrée dans votre code, la séquence d'événements suivante se produit :

1. La variable de boucle est initialisée.
2. L'expression booléenne est évaluée. Si l'expression est false, la boucle est ignorée et le programme continue avec la ligne de code suivante en dehors de la boucle.
3. Si l'expression est true, le corps de la boucle est exécuté.
4. La variable de boucle est incrémentée ou mise à jour.
5. Les étapes 2 à 4 sont répétées jusqu'à ce que l'expression booléenne devienne false.

Intégrer IronPDF pour générer des rapports avec des boucles for

Découvrez les capacités de génération de PDF d'IronPDF pour créer des rapports PDF dynamiques et robustes en C#. Cela peut être un outil utile lorsque vous travaillez avec des boucles for, surtout si vous devez créer des rapports ou des documents dynamiques basés sur les données traitées dans vos boucles. Dans cette section, nous allons vous montrer comment utiliser IronPDF en conjonction avec les boucles for en C# pour générer un rapport simple.

Tout d'abord, vous devrez installer le package NuGet d'IronPDF. Vous pouvez le faire en utilisant la console du gestionnaire de packages dans Visual Studio :

Install-Package IronPdf

Une fois que vous avez installé IronPDF, créons un exemple simple qui génère un rapport PDF à partir de HTML avec IronPDF contenant un tableau de nombres et leurs carrés à l'aide d'une boucle for.

Étape 1 : Ajoutez les espaces de noms nécessaires.

using IronPdf;
using System.IO;

using IronPdf;
using System.IO;

Imports IronPdf
Imports System.IO

Étape 2 : Créez une nouvelle méthode appelée GenerateReport.

static void GenerateReport()
{
    // Create an HTML template for the report
    var htmlTemplate = @"
    <html>
        <head>
            <style>
                table {
                    border-collapse: collapse;
                    width: 100%;
                }

                th, td {
                    border: 1px solid black;
                    padding: 8px;
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Number Squares Report</h1>
            <table>
                <thead>
                    <tr>
                        <th>Number</th>
                        <th>Square</th>
                    </tr>
                </thead>
                <tbody>
                    {0}
                </tbody>
            </table>
        </body>
    </html>";

    // Generate the table rows using a for loop
    string tableRows = "";
    for (int i = 1; i <= 10; i++)
    {
        tableRows += $"<tr><td>{i}</td><td>{i * i}</td></tr>";
    }

    // Insert the generated table rows into the HTML template
    string finalHtml = string.Format(htmlTemplate, tableRows);

    // Create a new PDF document from the HTML using IronPdf
    var pdf = new IronPdf.ChromePdfRenderer();
    var document = pdf.RenderHtmlAsPdf(finalHtml);

    // Save the PDF to a file
    document.SaveAs("NumberSquaresReport.pdf");
}

static void GenerateReport()
{
    // Create an HTML template for the report
    var htmlTemplate = @"
    <html>
        <head>
            <style>
                table {
                    border-collapse: collapse;
                    width: 100%;
                }

                th, td {
                    border: 1px solid black;
                    padding: 8px;
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Number Squares Report</h1>
            <table>
                <thead>
                    <tr>
                        <th>Number</th>
                        <th>Square</th>
                    </tr>
                </thead>
                <tbody>
                    {0}
                </tbody>
            </table>
        </body>
    </html>";

    // Generate the table rows using a for loop
    string tableRows = "";
    for (int i = 1; i <= 10; i++)
    {
        tableRows += $"<tr><td>{i}</td><td>{i * i}</td></tr>";
    }

    // Insert the generated table rows into the HTML template
    string finalHtml = string.Format(htmlTemplate, tableRows);

    // Create a new PDF document from the HTML using IronPdf
    var pdf = new IronPdf.ChromePdfRenderer();
    var document = pdf.RenderHtmlAsPdf(finalHtml);

    // Save the PDF to a file
    document.SaveAs("NumberSquaresReport.pdf");
}

Shared Sub GenerateReport()
	' Create an HTML template for the report
	Dim htmlTemplate = "
    <html>
        <head>
            <style>
                table {
                    border-collapse: collapse;
                    width: 100%;
                }

                th, td {
                    border: 1px solid black;
                    padding: 8px;
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Number Squares Report</h1>
            <table>
                <thead>
                    <tr>
                        <th>Number</th>
                        <th>Square</th>
                    </tr>
                </thead>
                <tbody>
                    {0}
                </tbody>
            </table>
        </body>
    </html>"

	' Generate the table rows using a for loop
	Dim tableRows As String = ""
	For i As Integer = 1 To 10
		tableRows &= $"<tr><td>{i}</td><td>{i * i}</td></tr>"
	Next i

	' Insert the generated table rows into the HTML template
	Dim finalHtml As String = String.Format(htmlTemplate, tableRows)

	' Create a new PDF document from the HTML using IronPdf
	Dim pdf = New IronPdf.ChromePdfRenderer()
	Dim document = pdf.RenderHtmlAsPdf(finalHtml)

	' Save the PDF to a file
	document.SaveAs("NumberSquaresReport.pdf")
End Sub

Appelez la méthode GenerateReport depuis votre fichier Program.cs :

GenerateReport();

GenerateReport();

GenerateReport()

Lorsque vous exécutez cet exemple, un rapport PDF appelé "NumberSquaresReport.pdf" sera généré dans le répertoire de sortie de votre application. Le rapport contiendra un tableau de nombres de 1 à 10 et leurs carrés, générés à l'aide d'une boucle for en C#.

Conclusion

En conclusion, ce tutoriel complet vous a fourni une base solide sur les boucles for en C# et leurs concepts associés. Nous avons exploré les variables de boucle, les corps de boucle, les variables d'itération, les boucles internes et externes, les boucles infinies, les expressions booléennes, les blocs de code, les boucles imbriquées, et même démontré comment intégrer la puissante bibliothèque IronPDF pour générer des rapports PDF dynamiques en utilisant des boucles for.

IronPDF offre un essai gratuit d'IronPDF pour vous permettre de tester ses capacités, et si vous le trouvez utile, les licences commencent à partir d'options abordables adaptées à vos besoins.