For Loop C# (Comment ça marche pour les développeurs)

Dans ce tutoriel complet, nous couvrirons tout ce que vous devez savoir pour commencer avec les boucles for dans la méthode public static void Main. Nous explorerons les boucles for, 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 boucles imbriquées, etc. Commençons !

Premiers pas avec les boucles for

Une boucle for est un type de boucle en C#, spécifiquement 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

Décortiquons 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 des instructions plusieurs fois ou non.

3. Incrément : Cette instruction met à jour la variable d'itération après chaque itération.

Variables statiques Void Main et Loop

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 ici que votre programme commence à s'exécuter. Voici un exemple d'utilisation d'une 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 en tant que 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 en C# sont des boucles qui sont placées à l'intérieur d'autres boucles, formant une boucle interne et une boucle externe avec des sections itératives. Ceux-ci peuvent être utiles lorsque vous travaillez avec des structures de données multidimensionnelles telles que des matrices ou lorsque vous devez effectuer une certaine opération sur chaque combinaison d'éléments.

Voici un exemple de 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 alors 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 parce que sa condition de test ne devient jamais fausse. Celles-ci peuvent être dangereuses, car elles peuvent bloquer votre programme indéfiniment. Faites preuve de prudence lors de l'écriture de boucles telles que les boucles while ou foreach pour vous assurer que la condition de sortie finira par être remplie. Voici un exemple de 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 for standard, 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 est utilisée pour sortir immédiatement de la boucle. Lorsqu'une instruction break est rencontrée, la boucle se termine, et le programme continue avec la ligne de code suivante en dehors de la boucle.

• continue : Cette instruction est utilisée pour passer le code restant dans le corps de la boucle pour l'itération actuelle et passer à l'itération suivante de la boucle.

  Voici un exemple démontrant 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 s'arrête 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 la boucle est un booléen 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 sont les suivantes :

• Comparaisons : i < 10, i >= 10, i >= 10, i == 10, i != 10

• Opérateurs logiques : && (ET), **

  ** (OU), **!`** (NON)

  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 n'est pas égal à 5.

Blocs de code et corps de boucle

Un bloc de code est un groupe d'instructions encadré par des accolades {}. Dans une boucle for, le bloc de code qui suit la déclaration de la boucle est appelé corps de la boucle. C'est ici 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 affiche le numéro de l'itération actuelle.

Étapes d'exécution de la boucle

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

1. La variable de la 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 la 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égration d'IronPDF pour la génération de 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#. Il peut s'agir d'un outil utile lorsque vous travaillez avec des boucles for, en particulier 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 des boucles C# pour générer un rapport simple.

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

    Install-Package IronPDF

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

Étape 1 : Ajouter 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 two variables
    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 two variables
    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 two variables
	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 intitulé "NumberSquaresReport.pdf" est généré dans le répertoire de sortie de votre application. Le rapport contiendra un tableau des nombres de 1 à 10 et de leurs carrés, généré à l'aide d'une boucle for C#.

Conclusion

En conclusion, ce tutoriel complet vous a fourni une base solide en C# pour les boucles et leurs concepts connexes. 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 nous avons même montré comment intégrer la puissante bibliothèque IronPDF pour générer des rapports PDF dynamiques à l'aide de boucles for.

IronPDF propose 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.