C# pour chacun (Comment les technologies de l'information fonctionnent pour les développeurs)

Dans ce tutoriel, nous aborderons la boucle "foreach" en C#, un outil essentiel pour les développeurs. La boucle foreach simplifie le processus d'itération à travers une collection, facilitant l'exécution d'opérations sur chaque élément sans se soucier des détails sous-jacents. Nous discuterons de l'importance de foreach, de ses cas d'utilisation et de la manière de l'implémenter dans votre code C#.

Introduction à la boucle foreach (avant)

La boucle foreach est un outil puissant qui permet aux développeurs de parcourir des collections de manière concise et lisible. Il simplifie le code et réduit les risques d'erreurs, car il n'est pas nécessaire de gérer manuellement l'index ou le nombre d'éléments de la collection. En termes de déclarations de variables, la boucle foreach comporte cinq déclarations de variables, alors que la boucle for n'en comporte que trois.

Les cas d'utilisation de foreach incluent :

• Récapitulation des valeurs d'une collection
• Recherche d'un élément dans une collection
• Modifier les éléments d'une collection
• Effectuer des actions sur chaque élément d'une collection

Comprendre les collections

Il existe différents types de collections en C# qui sont utilisées pour stocker un groupe d'éléments dans un seul objet. Il s'agit notamment des tableaux, des listes, des dictionnaires, etc. La boucle foreach est un outil utile qui peut être utilisé avec n'importe quelle collection qui implémente l'interface IEnumerable ou IEnumerable.

Les types de collecte les plus courants sont les suivants

• Tableaux : Collection d'éléments de taille fixe ayant le même type de données.
• Listes : Une collection dynamique d'éléments ayant le même type de données.

• Dictionnaires : Une collection de paires clé-valeur, où chaque clé est unique.

  L'espace de nom System.Collections.Generic contient la méthode d'extension ForEach qui peut être utilisée avec n'importe quelle classe de collection intégrée.

Mise en œuvre de l'instruction foreach dans C# ;

Maintenant que nous avons une compréhension de base des collections et de la boucle for each, plongeons dans la syntaxe et voyons comment elle fonctionne en C#.

Syntaxe de la boucle For Each

    foreach (variableType variableName in collection)
    {
        // Code to execute for each item
    }

    foreach (variableType variableName in collection)
    {
        // Code to execute for each item
    }

For Each variableName As variableType In collection
		' Code to execute for each item
Next variableName

Ici, variableType représente le type de données des éléments de la collection, variableName est le nom donné à l'élément courant de la boucle(variable de boucle)et collection fait référence à la collection sur laquelle vous voulez itérer.

Exemple

Prenons l'exemple d'une liste d'entiers dont nous voulons trouver la somme de tous les éléments.

    using System;
    using System.Collections.Generic;

            // Create a list of integers
            List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

            // Initialize a variable to store the sum
            int sum = 0;

            // Iterate through the list using for each loop
            foreach (int number in numbers)
            {
                sum += number;
            }

            // Print the sum
            Console.WriteLine("The sum of the elements is: " + sum);

    using System;
    using System.Collections.Generic;

            // Create a list of integers
            List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

            // Initialize a variable to store the sum
            int sum = 0;

            // Iterate through the list using for each loop
            foreach (int number in numbers)
            {
                sum += number;
            }

            // Print the sum
            Console.WriteLine("The sum of the elements is: " + sum);

IRON VB CONVERTER ERROR developers@ironsoftware.com

Sortie

Lorsque la boucle s'exécute, elle produit la sortie suivante.

    The sum of the elements is: 15

    The sum of the elements is: 15

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'The sum @of the elements is: 15

Dans l'exemple ci-dessus, nous créons d'abord une liste d'entiers appelée numbers et nous initialisons une variable sum pour stocker la sum des éléments. Ensuite, nous utilisons la boucle foreach pour parcourir la liste et ajouter la valeur de chaque élément à la somme. Enfin, nous imprimons la somme sur la console. Nous pouvons également imprimer un tableau en utilisant la boucle foreach de la même manière.

Variations et bonnes pratiques

Maintenant que nous avons une compréhension de base de l'utilisation de la boucle for each, examinons quelques variantes et les meilleures pratiques.

Itération en lecture seule : La boucle for each est mieux adaptée à l'itération en lecture seule, car la modification de la collection pendant l'itération peut entraîner des résultats inattendus ou des erreurs d'exécution. Si vous devez modifier la collection pendant l'itération, envisagez d'utiliser une boucle for traditionnelle ou de créer une nouvelle collection avec les modifications souhaitées.

Utilisation du mot-clé var : Au lieu de spécifier explicitement le type de données des éléments de la collection, vous pouvez utiliser le mot-clé var pour laisser le compilateur déduire le type de données. Cela peut rendre le code plus concis et plus facile à maintenir.

Exemple :

    foreach (var number in numbers)
    {
        Console.WriteLine(number);
    }

    foreach (var number in numbers)
    {
        Console.WriteLine(number);
    }

For Each number In numbers
		Console.WriteLine(number)
Next number

Itération à travers les dictionnaires: Lorsque vous utilisez une boucle for each pour itérer à travers les dictionnaires, vous devez travailler avec la structure KeyValuePair. Cette structure représente une paire clé-valeur dans un dictionnaire.

Exemple :

    Dictionary<string, int> ageDictionary = new Dictionary<string, int>
    {
        { "Alice", 30 },
        { "Bob", 25 },
        { "Charlie", 22 }
    };

    foreach (KeyValuePair<string, int> entry in ageDictionary)
    {
        Console.WriteLine($"{entry.Key} is {entry.Value} years old.");
    }

    Dictionary<string, int> ageDictionary = new Dictionary<string, int>
    {
        { "Alice", 30 },
        { "Bob", 25 },
        { "Charlie", 22 }
    };

    foreach (KeyValuePair<string, int> entry in ageDictionary)
    {
        Console.WriteLine($"{entry.Key} is {entry.Value} years old.");
    }

Dim ageDictionary As New Dictionary(Of String, Integer) From {
	{"Alice", 30},
	{"Bob", 25},
	{"Charlie", 22}
}

	For Each entry As KeyValuePair(Of String, Integer) In ageDictionary
		Console.WriteLine($"{entry.Key} is {entry.Value} years old.")
	Next entry

LINQ et pour chaque: LINQ(Langue Requête intégrée) est une fonctionnalité puissante de C# qui vous permet d'interroger et de manipuler des données d'une manière plus déclarative. Vous pouvez utiliser LINQ avec la boucle for each pour créer un code plus expressif et plus efficace.

Exemple :

    using System;
    using System.Collections.Generic;
    using System.Linq;
            List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

            // Use LINQ to filter out even numbers
            var evenNumbers = numbers.Where(n => n % 2 == 0);

            // Iterate through the even numbers using for each loop
            foreach (var number in evenNumbers)
            {
                Console.WriteLine(number);
            }

    using System;
    using System.Collections.Generic;
    using System.Linq;
            List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

            // Use LINQ to filter out even numbers
            var evenNumbers = numbers.Where(n => n % 2 == 0);

            // Iterate through the even numbers using for each loop
            foreach (var number in evenNumbers)
            {
                Console.WriteLine(number);
            }

Imports System
	Imports System.Collections.Generic
	Imports System.Linq
			Private numbers As New List(Of Integer) From {1, 2, 3, 4, 5}

			' Use LINQ to filter out even numbers
			Private evenNumbers = numbers.Where(Function(n) n Mod 2 = 0)

			' Iterate through the even numbers using for each loop
			For Each number In evenNumbers
				Console.WriteLine(number)
			Next number

Ajout de la fonctionnalité IronPDF au tutoriel C# for each

Dans cette section, nous allons prolonger notre tutoriel sur la boucle "C# pour chacun" en présentant IronPDF, une bibliothèque populaire permettant de travailler avec des fichiers PDF en C#. Nous allons montrer comment utiliser la boucle foreach en conjonction avec IronPDF pour générer un rapport PDF basé sur une collection de données.

Présentation d'IronPDF

Documentation IronPDF est une puissante bibliothèque permettant de créer, d'éditer et d'extraire du contenu de fichiers PDF en C#. Il fournit une API facile à utiliser pour travailler avec des documents PDF, ce qui en fait un excellent choix pour les développeurs qui ont besoin d'incorporer des fonctionnalités PDF dans leurs applications.

Voici quelques-unes des principales caractéristiques d'IronPDF :

• Générer des PDF à partir de HTML, d'URL et d'images
• Édition de documents PDF existants
• Extraction de texte et d'images à partir de PDF
• Ajout d'annotations, de champs de formulaire et de cryptage aux PDF

Installation d'IronPDF

Pour commencer à utiliser IronPDF, vous devez installer le paquetage NuGet IronPDF. Pour ce faire, vous pouvez suivre les instructions à l'adresse suivanteInstallation d'IronPDF.

Générer un rapport PDF avec IronPDF et pour chaque

Dans cet exemple, nous utiliserons la bibliothèque IronPDF et la boucle for each pour créer un rapport PDF d'une liste de produits, avec leurs noms et leurs prix.

Tout d'abord, créons une simple classe Produit pour représenter les produits :

    public class Product
    {
        public string Name { get; set; }
        public decimal Price { get; set; }

        public Product(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
    }

    public class Product
    {
        public string Name { get; set; }
        public decimal Price { get; set; }

        public Product(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
    }

Public Class Product
		Public Property Name() As String
		Public Property Price() As Decimal

		Public Sub New(ByVal name As String, ByVal price As Decimal)
			Me.Name = name
			Me.Price = price
		End Sub
End Class

Ensuite, créons une liste d'objets Produit pour générer le rapport PDF :

    List<Product> products = new List<Product>
    {
        new Product("Product A", 29.99m),
        new Product("Product B", 49.99m),
        new Product("Product C", 19.99m),
    };

    List<Product> products = new List<Product>
    {
        new Product("Product A", 29.99m),
        new Product("Product B", 49.99m),
        new Product("Product C", 19.99m),
    };

Dim products As New List(Of Product) From {
	New Product("Product A", 29.99D),
	New Product("Product B", 49.99D),
	New Product("Product C", 19.99D)
}

Nous pouvons maintenant utiliser IronPDF et la boucle for each pour générer un rapport PDF contenant les informations sur le produit :

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

    // Create a list of products
    List<Product> products = new List<Product>
    {
        new Product("Product A", 29.99m),
        new Product("Product B", 49.99m),
        new Product("Product C", 19.99m),
    };

    // Initialize an HTML string to store the report content
    string htmlReport = "<table><tr><th>Product Name</th><th>Price</th></tr>";

    // Iterate through the list of products using for each loop
    foreach (var product in products)
    {
        // Add product information to the HTML report
        htmlReport += $"<tr><td>{product.Name}</td><td>${product.Price}</td></tr>";
    }

    // Close the table tag in the HTML report
    htmlReport += "</table>";

    // Create a new instance of the HtmlToPdf class
    var htmlToPdf = new ChromePdfRenderer();

    // Generate the PDF from the HTML report
    var PDF = htmlToPdf.RenderHtmlAsPdf(htmlReport);

    // Save the PDF to a file
    PDF.SaveAs("ProductReport.PDF");

    // Inform the user that the PDF has been generated
    Console.WriteLine("ProductReport.PDF has been generated.");

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

    // Create a list of products
    List<Product> products = new List<Product>
    {
        new Product("Product A", 29.99m),
        new Product("Product B", 49.99m),
        new Product("Product C", 19.99m),
    };

    // Initialize an HTML string to store the report content
    string htmlReport = "<table><tr><th>Product Name</th><th>Price</th></tr>";

    // Iterate through the list of products using for each loop
    foreach (var product in products)
    {
        // Add product information to the HTML report
        htmlReport += $"<tr><td>{product.Name}</td><td>${product.Price}</td></tr>";
    }

    // Close the table tag in the HTML report
    htmlReport += "</table>";

    // Create a new instance of the HtmlToPdf class
    var htmlToPdf = new ChromePdfRenderer();

    // Generate the PDF from the HTML report
    var PDF = htmlToPdf.RenderHtmlAsPdf(htmlReport);

    // Save the PDF to a file
    PDF.SaveAs("ProductReport.PDF");

    // Inform the user that the PDF has been generated
    Console.WriteLine("ProductReport.PDF has been generated.");

Imports System
	Imports System.Collections.Generic
	Imports IronPdf

	' Create a list of products
	Private products As New List(Of Product) From {
		New Product("Product A", 29.99D),
		New Product("Product B", 49.99D),
		New Product("Product C", 19.99D)
	}

	' Initialize an HTML string to store the report content
	Private htmlReport As String = "<table><tr><th>Product Name</th><th>Price</th></tr>"

	' Iterate through the list of products using for each loop
	For Each product In products
		' Add product information to the HTML report
		htmlReport &= $"<tr><td>{product.Name}</td><td>${product.Price}</td></tr>"
	Next product

	' Close the table tag in the HTML report
	htmlReport &= "</table>"

	' Create a new instance of the HtmlToPdf class
	Dim htmlToPdf = New ChromePdfRenderer()

	' Generate the PDF from the HTML report
	Dim PDF = htmlToPdf.RenderHtmlAsPdf(htmlReport)

	' Save the PDF to a file
	PDF.SaveAs("ProductReport.PDF")

	' Inform the user that the PDF has been generated
	Console.WriteLine("ProductReport.PDF has been generated.")

Conclusion

Tout au long de ce tutoriel, nous avons exploré les principes fondamentaux de la boucle "C# for each", son importance, ses cas d'utilisation et la manière de la mettre en œuvre dans votre code. Nous avons également présenté IronPDF, une puissante bibliothèque permettant de travailler avec des fichiers PDF en C#, et montré comment utiliser la boucle for each en conjonction avec IronPDF pour générer un rapport PDF à partir d'un ensemble de données.

Continuez à apprendre et à développer vos compétences, et vous serez bientôt en mesure d'exploiter tout le potentiel de la boucle for each et d'autres fonctionnalités de C# pour créer des applications robustes et efficaces. IronPDF propose un service deessai gratuit pour tester la bibliothèque. Si vous décidez de l'acheter, la licence IronPDF commence à partir de $749.