C# foreach avec index (Comment ça marche pour les développeurs)

En C#, l'optioninstruction foreach est généralement utilisé pour itérer sur des collections telles que des tableaux, des listes ou d'autres types énumérables. Cependant, la boucle foreach n'offre pas de variable d'index intégrée pour suivre l'itération en cours. Les développeurs ont souvent besoin d'accéder à l'index de l'élément courant. Ci-dessous, nous explorerons les différentes façons de mettre en œuvre cette fonctionnalité ainsi que l'approche de la traductionBibliothèque IronPDF.

Les bases de la boucle foreach

La boucle foreach est conçue pour simplifier l'itération dans les tableaux, les listes, les dictionnaires et autres types qui implémentent IEnumerable. Voici un exemple élémentaire de l'utilisation d'une instruction foreach pour parcourir en boucle un tableau d'entiers :

int[] numbers = { 10, 20, 30, 40 };
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

int[] numbers = { 10, 20, 30, 40 };
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
For Each number As Integer In numbers
	Console.WriteLine(number)
Next number

Dans cet exemple, le nombre représente l'élément de la collection à chaque itération. La boucle parcourt automatiquement tous les éléments du tableau. Cependant, il n'existe aucun moyen intégré d'accéder à l'index de l'élément courant.

Gestion de l'index dans une boucle foreach

Bien que C# ne fournisse pas directement l'index dans une boucle foreach, plusieurs techniques permettent de résoudre ce problème. Examinons ces méthodes en détail.

Méthode 1 : Utilisation d'une variable distincte

L'une des façons les plus simples d'obtenir l'index de l'élément courant est d'utiliser une variable d'index externe. Vous devrez l'incrémenter manuellement à l'intérieur de la boucle :

int[] numbers = { 10, 20, 30, 40 };
int numberIndex = 0;
foreach (int number in numbers)
{
    Console.WriteLine($"Index: {numberIndex}, Value: {number}");
    numberIndex++;
}

int[] numbers = { 10, 20, 30, 40 };
int numberIndex = 0;
foreach (int number in numbers)
{
    Console.WriteLine($"Index: {numberIndex}, Value: {number}");
    numberIndex++;
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
Dim numberIndex As Integer = 0
For Each number As Integer In numbers
	Console.WriteLine($"Index: {numberIndex}, Value: {number}")
	numberIndex += 1
Next number

Dans ce code, la variable index est initialisée avant le début de la boucle, puis incrémentée à l'intérieur de la boucle à chaque itération. Bien que cette approche fonctionne, elle nécessite une mise à jour manuelle de l'index, ce qui n'est pas toujours idéal.

Méthode 2 : Utilisation de la méthode Select de LINQ

La méthode Select de LINQ peut être utilisée pour projeter chaque élément d'une collection dans une nouvelle forme, y compris son index. En voici un exemple :

int[] numbers = { 10, 20, 30, 40 };
foreach (var item in numbers.Select((value, index) => new { value, index }))
{
    Console.WriteLine($"Index: {item.index}, Value: {item.value}");
}

int[] numbers = { 10, 20, 30, 40 };
foreach (var item in numbers.Select((value, index) => new { value, index }))
{
    Console.WriteLine($"Index: {item.index}, Value: {item.value}");
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
For Each item In numbers.Select(Function(value, index) New With {
	Key value,
	Key index
})
	Console.WriteLine($"Index: {item.index}, Value: {item.value}")
Next item

Dans cet exemple, Select crée un objet anonyme qui contient à la fois la valeur de l'élément courant et son index. La boucle foreach peut alors itérer sur ces objets et accéder directement à l'index et à la valeur.

Méthode 3 : Utilisation d'un itérateur personnalisé

Vous pouvez mettre en œuvre une méthode d'extension d'itérateur personnalisée en utilisant le mot-clé de retour yield pour générer une méthode qui produit à la fois l'élément actuel et son index. Il s'agit d'une solution un peu plus avancée mais flexible.

public static IEnumerable<(int index, T value)> WithIndex<T>(this IEnumerable<T> source)
{
    int index = 0;
    foreach (T value in source)
    {
        yield return (index, value);
        index++;
    }
}

public static IEnumerable<(int index, T value)> WithIndex<T>(this IEnumerable<T> source)
{
    int index = 0;
    foreach (T value in source)
    {
        yield return (index, value);
        index++;
    }
}

<System.Runtime.CompilerServices.Extension> _
Public Function WithIndex(Of T)(ByVal source As IEnumerable(Of T)) As IEnumerable(Of (index As Integer, value As T))
	Dim index As Integer = 0
	For Each value As T In source
		Yield (index, value)
		index += 1
	Next value
End Function

Vous pouvez désormais utiliser cette méthode d'extension pour vos collections :

int[] numbers = { 10, 20, 30, 40 };
foreach (var (index, value) in numbers.WithIndex())
{
    Console.WriteLine($"Index: {index}, Value: {value}");
}

int[] numbers = { 10, 20, 30, 40 };
foreach (var (index, value) in numbers.WithIndex())
{
    Console.WriteLine($"Index: {index}, Value: {value}");
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
foreach var(index, value) In numbers.WithIndex()
	Console.WriteLine($"Index: {index}, Value: {value}")
Next

Cette approche apporte une solution plus élégante au problème du foreach avec index en faisant abstraction de la gestion manuelle de l'index dans une méthode réutilisable.

Utilisation d'une boucle while pour accéder aux index

Si vous travaillez avec des collections telles que des tableaux ou des listes, vous pouvez utiliser une boucle while en conjonction avec une variable d'index pour accéder à la fois à l'index et à l'élément actuel :

int[] numbers = { 10, 20, 30, 40 };
int index = 0;
while (index < numbers.Length)
{
    Console.WriteLine($"Index: {index}, Value: {numbers[index]}");
    index++;
}

int[] numbers = { 10, 20, 30, 40 };
int index = 0;
while (index < numbers.Length)
{
    Console.WriteLine($"Index: {index}, Value: {numbers[index]}");
    index++;
}

Dim numbers() As Integer = { 10, 20, 30, 40 }
Dim index As Integer = 0
Do While index < numbers.Length
	Console.WriteLine($"Index: {index}, Value: {numbers(index)}")
	index += 1
Loop

Cette méthode permet d'accéder directement à l'index et à l'élément courant en utilisant la variable index comme indice du tableau ou de la liste.

Collections et itérateurs personnalisés dans .NET

Si vous travaillez avec des collections personnalisées, vous pouvez implémenter vos itérateurs pour prendre en charge l'accès indexé. En mettant en œuvre l'interface IEnumerable et en utilisant l'instruction de retour yield, vous pouvez créer des itérateurs qui renvoient à la fois l'élément et son index.

Voici un exemple de création d'une collection personnalisée qui met en œuvre IEnumerable :

public class CustomCollection<T> : IEnumerable<T>
{
    private T[] _items;
    public CustomCollection(T[] items)
    {
        _items = items;
    }
    public IEnumerator<T> GetEnumerator()
    {
        for (int i = 0; i < _items.Length; i++)
        {
            yield return _items[i];
        }
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class CustomCollection<T> : IEnumerable<T>
{
    private T[] _items;
    public CustomCollection(T[] items)
    {
        _items = items;
    }
    public IEnumerator<T> GetEnumerator()
    {
        for (int i = 0; i < _items.Length; i++)
        {
            yield return _items[i];
        }
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Public Class CustomCollection(Of T)
	Implements IEnumerable(Of T)

	Private _items() As T
	Public Sub New(ByVal items() As T)
		_items = items
	End Sub
	Public Iterator Function GetEnumerator() As IEnumerator(Of T) Implements IEnumerable(Of T).GetEnumerator
		For i As Integer = 0 To _items.Length - 1
			Yield _items(i)
		Next i
	End Function
	Private Iterator Function IEnumerable_GetEnumerator() As IEnumerator Implements IEnumerable.GetEnumerator
		Return GetEnumerator()
	End Function
End Class

Vous pouvez ensuite utiliser cette collection personnalisée dans une boucle foreach :

var customCollection = new CustomCollection<int>(new int[] { 10, 20, 30, 40 });
foreach (int number in customCollection)
{
    Console.WriteLine(number);
}

var customCollection = new CustomCollection<int>(new int[] { 10, 20, 30, 40 });
foreach (int number in customCollection)
{
    Console.WriteLine(number);
}

Dim customCollection As New CustomCollection(Of Integer)(New Integer() { 10, 20, 30, 40 })
For Each number As Integer In customCollection
	Console.WriteLine(number)
Next number

En mettant en œuvre la méthode GetEnumerator et en utilisant yield return, vous créez un itérateur qui permet à la boucle foreach de travailler avec votre collection personnalisée comme n'importe quelle autre collection dans .NET.

Utilisation de dictionnaires et itération avec des paires clé-valeur

Lorsque vous travaillez avec des dictionnaires, la boucle foreach vous permet d'itérer directement sur les paires clé-valeur. Il s'agit d'un cas d'utilisation courant pour accéder à la fois à la clé et à la valeur à chaque itération :

Dictionary<int, string> dict = new Dictionary<int, string>
{
    { 1, "Apple" },
    { 2, "Banana" },
    { 3, "Cherry" }
};
foreach (var kvp in dict)
{
    Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
}

Dictionary<int, string> dict = new Dictionary<int, string>
{
    { 1, "Apple" },
    { 2, "Banana" },
    { 3, "Cherry" }
};
foreach (var kvp in dict)
{
    Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
}

Dim dict As New Dictionary(Of Integer, String) From {
	{1, "Apple"},
	{2, "Banana"},
	{3, "Cherry"}
}
For Each kvp In dict
	Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}")
Next kvp

Dans cet exemple, kvp.Key vous donne la clé actuelle et kvp.Value vous donne la valeur actuelle.

Utiliser IronPDF avec C&num ; foreach Loop et Index

IronPDF est une bibliothèque PDF permettant de gérer les éléments suivantsGénération de PDF à partir de HTML et d'autres tâches liées aux PDF en C#. Elle est également compatible avec la dernière version de .NET Framework. Lorsque vous générez des PDF à l'aide d'IronPDF, vous pouvez avoir besoin d'itérer sur une collection de données et d'insérer dynamiquement du contenu dans votre fichier PDF. La combinaison de la boucle foreach avec la gestion de l'index vous permet de gérer le positionnement, la numérotation ou la logique personnalisée en fonction de l'index de l'élément actuel de la collection. Voici un exemple pratique d'utilisation d'IronPDF pour créer un PDF dans lequel chaque élément d'une collection est inséré dans le document, ainsi que son index.

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        // Create a new PDF document
        var pdf = new ChromePdfRenderer();
        // Sample data array
        string[] items = { "First Item", "Second Item", "Third Item" };
        // Initialize the HTML content with foreach loop and index
        string htmlContent = "<html><body>";
        int index = 0;
        foreach (var item in items)
        {
            htmlContent += $"<h2>Item {index + 1}: {item}</h2>";
            index++;
        }
        htmlContent += "</body></html>";
        // Render the HTML to PDF
        var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
        // Save the PDF document
        pdfDocument.SaveAs("output.pdf");
        // Notify completion
        Console.WriteLine("PDF created successfully with indexed items.");
    }
}

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        // Create a new PDF document
        var pdf = new ChromePdfRenderer();
        // Sample data array
        string[] items = { "First Item", "Second Item", "Third Item" };
        // Initialize the HTML content with foreach loop and index
        string htmlContent = "<html><body>";
        int index = 0;
        foreach (var item in items)
        {
            htmlContent += $"<h2>Item {index + 1}: {item}</h2>";
            index++;
        }
        htmlContent += "</body></html>";
        // Render the HTML to PDF
        var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
        // Save the PDF document
        pdfDocument.SaveAs("output.pdf");
        // Notify completion
        Console.WriteLine("PDF created successfully with indexed items.");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a new PDF document
		Dim pdf = New ChromePdfRenderer()
		' Sample data array
		Dim items() As String = { "First Item", "Second Item", "Third Item" }
		' Initialize the HTML content with foreach loop and index
		Dim htmlContent As String = "<html><body>"
		Dim index As Integer = 0
		For Each item In items
			htmlContent &= $"<h2>Item {index + 1}: {item}</h2>"
			index += 1
		Next item
		htmlContent &= "</body></html>"
		' Render the HTML to PDF
		Dim pdfDocument = pdf.RenderHtmlAsPdf(htmlContent)
		' Save the PDF document
		pdfDocument.SaveAs("output.pdf")
		' Notify completion
		Console.WriteLine("PDF created successfully with indexed items.")
	End Sub
End Class

Voici le fichier PDF de sortie :

Conclusion

En C#, si la boucle foreach est un moyen pratique d'itérer sur des collections, elle ne prend pas en charge l'indexation en natif. Cependant, il existe plusieurs façons de surmonter cette limitation. Que vous utilisiez une simple variable d'index, la méthode Select de LINQ ou des itérateurs personnalisés, vous pouvez accéder à l'index de l'élément actuel ou suivant pendant l'itération. La compréhension de ces techniques peut vous aider à utiliser plus efficacement la boucle foreach, en particulier lorsque vous avez besoin de connaître l'index de chaque élément.

Avec IronPDF, vous n'avez pas besoin de vous engager tout de suite. Nous offrons un service deessai gratuit la traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. Si vous aimez ce que vous voyez, les licences commencent à 749 $.