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

Dans ce tutoriel complet, nous allons couvrir tout ce que vous devez savoir pour commencer avec la boucle for dans la méthode public static void Main. Nous explorerons la boucle 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, et bien d'autres choses encore. Commençons!

Premiers pas avec les boucles for

Une boucle for est un type de boucle en C#, spécialement conçu 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 suivant

    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(Chaîne []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 first for loop!");
            }
        }
    }

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans cet exemple, la variable de boucle int i est initialisée à 0 et joue le rôle de 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

Boucles imbriquées sont des boucles placées à l'intérieur d'autres boucles, formant une boucle intérieure et une boucle extérieure avec des sections d'itération. Elles 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 itère ensuite à travers 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. Soyez prudent lorsque vous écrivez des boucles telles que la boucle while, la boucle foreach afin de vous assurer que la condition de sortie sera finalement 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 standard des boucles, 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 sauter le code restant dans le corps de la boucle pour l'itération en cours 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}");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans cet exemple, la boucle s'arrête lorsque i atteint 5. L'instruction continue est utilisée pour sauter 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écute que si l'expression est "vraie". 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), **!`** (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écute 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 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 consiste en une seule instruction Console.WriteLine qui affiche le numéro de l'itération en cours.

É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 sautée, et le programme continue avec la ligne de code suivante en dehors de la boucle.
3. Si l'expression est vrai, 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 "faux".

Intégration d'IronPDF pour la génération de rapports avec des boucles "For"

IronPDF est une puissante bibliothèque permettant de générer, d'éditer et de rendre des PDF 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 exemple simple qui génère un fichier Rapport PDF à partir de HTML 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éer 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");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

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 offre un service de essai gratuit pour que vous puissiez tester ses capacités, et si vous le trouvez utile, la licence commence à partir de $749.