Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. C# foreach com índice
AJUDA DO .NET

C# foreach com índice (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

Em C#, o comando foreach é normalmente usado para iterar sobre coleções como arrays, listas ou outros tipos enumeráveis. No entanto, uma limitação é que o loop foreach não fornece uma variável de índice integrada para acompanhar a iteração atual. Os desenvolvedores frequentemente precisam acessar o índice do elemento atual. A seguir, exploraremos várias maneiras de implementar essa funcionalidade e a biblioteca IronPDF .

Noções básicas do loop foreach

O loop foreach foi projetado para simplificar a iteração por arrays, listas, dicionários e outros tipos que implementam IEnumerable. Aqui está um exemplo básico de como usar uma instrução foreach para percorrer uma matriz de dados do tipo inteiro:

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
$vbLabelText   $csharpLabel

Neste exemplo, o number representa o elemento da coleção durante cada iteração. O loop itera automaticamente por todos os elementos da matriz. No entanto, não existe uma forma integrada de acessar o índice do elemento atual.

Manipulando o índice em um loop foreach

Embora o C# não forneça diretamente o índice em um loop foreach, diversas técnicas podem resolver isso. Vamos discutir esses métodos em detalhes.

Método 1: Utilizando uma variável separada

Uma das maneiras mais simples de obter o índice do elemento atual é usar uma variável de índice externa. Você precisará incrementá-lo manualmente dentro do loop:

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
$vbLabelText   $csharpLabel

Neste código, a variável de índice é inicializada antes do início do loop e, em seguida, incrementada dentro do loop durante cada iteração. Embora essa abordagem funcione, ela exige a manutenção manual do índice, o que nem sempre é o ideal.

Método 2: Usando o método Select do LINQ

O método Select do LINQ pode ser usado para projetar cada elemento de uma coleção em um novo formato, incluindo seu índice. Eis um exemplo:

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
$vbLabelText   $csharpLabel

Neste exemplo, Select cria um objeto anônimo que contém tanto o valor do elemento atual quanto seu índice. O loop foreach pode então iterar sobre esses objetos e acessar diretamente tanto o índice quanto o valor.

Método 3: Utilizando um Iterador Personalizado

Você pode implementar um método de extensão de iterador personalizado usando a palavra-chave yield return para gerar um método que retorna tanto o elemento atual quanto seu índice. Esta opção é um pouco mais avançada, mas oferece uma solução flexível.

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++;
    }
}
Imports System.Collections.Generic

Public Module Extensions
    <System.Runtime.CompilerServices.Extension> 
    Public Iterator Function WithIndex(Of T)(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
    End Function
End Module
$vbLabelText   $csharpLabel

Agora você pode usar esse método de extensão com suas coleções:

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
$vbLabelText   $csharpLabel

Essa abordagem cria uma solução mais elegante para o problema do foreach com índice, abstraindo o gerenciamento manual do índice em um método reutilizável.

Utilizando um loop while para acessar índices

Se você estiver trabalhando com coleções como arrays ou listas, pode usar um loop while em conjunto com uma variável de índice para acessar tanto o índice quanto o elemento atual:

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
$vbLabelText   $csharpLabel

C# foreach com índice (Como funciona para desenvolvedores): Figura 1 - Saída de índices

Este método permite acessar diretamente tanto o índice quanto o elemento atual, usando a variável de índice como um subscrito para a matriz ou lista.

Coleções e iteradores personalizados em .NET

Se você estiver trabalhando com coleções personalizadas, poderá implementar seus iteradores para oferecer suporte ao acesso indexado. Ao implementar a interface IEnumerable e usar a instrução yield return, você pode criar iteradores que retornam tanto o elemento quanto seu índice.

Aqui está um exemplo de como criar uma coleção personalizada que implementa a interface 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();
    }
}
Imports System.Collections
Imports System.Collections.Generic

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

    Private _items As T()

    Public Sub New(items As T())
        _items = items
    End Sub

    Public Function GetEnumerator() As IEnumerator(Of T) Implements IEnumerable(Of T).GetEnumerator
        For i As Integer = 0 To _items.Length - 1
            Yield _items(i)
        Next
    End Function

    Private Function IEnumerable_GetEnumerator() As IEnumerator Implements IEnumerable.GetEnumerator
        Return GetEnumerator()
    End Function
End Class
$vbLabelText   $csharpLabel

Em seguida, você pode usar essa coleção personalizada em um loop 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
$vbLabelText   $csharpLabel

Ao implementar o método GetEnumerator e usar yield return, você cria um iterador que permite que o loop foreach funcione com sua coleção personalizada como qualquer outra coleção no .NET.

Utilizando dicionários e iterando com pares chave-valor

Ao trabalhar com dicionários, o loop foreach permite iterar diretamente sobre pares de chave-valor. Este é um caso de uso comum para acessar tanto a chave quanto o valor durante cada iteração:

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
$vbLabelText   $csharpLabel

Neste exemplo, kvp.Key fornece a chave atual e kvp.Value fornece o valor atual.

Utilizando IronPDF com loop foreach e índice em C

C# foreach com índice (Como funciona para desenvolvedores): Figura 2 - IronPDF

IronPDF é uma biblioteca PDF para lidar com a geração de PDFs a partir de HTML e outras tarefas relacionadas a PDFs em C#. Também é compatível com a versão mais recente do .NET Framework . Ao gerar PDFs usando o IronPDF, você pode precisar iterar sobre uma coleção de dados e inserir conteúdo dinamicamente no seu arquivo PDF. Combinar o loop foreach com o tratamento de índices permite gerenciar o posicionamento, a numeração ou a lógica personalizada com base no índice do item atual na coleção. Aqui está um exemplo prático de como usar o IronPDF para criar um PDF onde cada item de uma coleção é inserido no documento, juntamente com seu índice.

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        // Create a new PDF document renderer
        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 renderer
        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 renderer
		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
$vbLabelText   $csharpLabel

Aqui está o arquivo PDF gerado:

C# foreach com índice (Como funciona para desenvolvedores): Figura 3 - Saída em PDF

Conclusão

C# foreach com índice (Como funciona para desenvolvedores): Figura 4 - Licenciamento

Em C#, embora o loop foreach seja uma maneira conveniente de iterar sobre coleções, ele não oferece suporte nativo para indexação. No entanto, existem diversas maneiras de superar essa limitação. Quer você use uma variável de índice simples, o método Select do LINQ ou iteradores personalizados, você pode acessar o índice do elemento atual ou do próximo elemento durante a iteração. Compreender essas técnicas pode ajudá-lo a usar o loop foreach de forma mais eficiente, especialmente quando você precisa saber o índice de cada elemento.

Com o IronPDF, você não precisa se comprometer imediatamente. Oferecemos um período de teste gratuito que lhe permite explorar em profundidade as funcionalidades do software. Se você gostou do que viu, as licenças começam em $799.

Perguntas frequentes

Como posso rastrear o índice de elementos em um loop foreach em C#?

Para rastrear o índice em um loop foreach em C#, você pode incrementar manualmente uma variável de índice separada, usar o método Select do LINQ para projetar elementos com seu índice ou criar um iterador personalizado que retorne tanto o elemento quanto seu índice.

O que é o método Select do LINQ e como ele auxilia na indexação?

O método Select do LINQ pode transformar cada elemento de uma coleção em um novo formato que inclui o índice do elemento. Essa projeção permite acessar tanto o elemento quanto seu índice durante a iteração em um loop foreach.

Como posso criar um iterador personalizado para indexação em C#?

Em C#, é possível criar um iterador personalizado usando a palavra-chave yield return . Isso permite construir um método que itera sobre uma coleção e retorna tanto o elemento atual quanto seu índice, simplificando a indexação em loops.

Uma biblioteca PDF pode auxiliar na criação de conteúdo indexado em C#?

Sim, uma biblioteca PDF como o IronPDF pode ser usada em conjunto com um loop foreach em C# para iterar sobre coleções de dados e inserir conteúdo indexado em um PDF. Essa abordagem permite o posicionamento dinâmico do conteúdo e a indexação precisa.

Como iterar sobre um dicionário usando um loop foreach em C#?

Em C#, um loop foreach pode iterar sobre um dicionário acessando cada par chave-valor. Isso permite que os desenvolvedores trabalhem diretamente com as chaves e os valores durante o processo de iteração.

Quais são os benefícios de usar bibliotecas PDF no desenvolvimento em C#?

Bibliotecas de PDF permitem que desenvolvedores gerem PDFs a partir de HTML e realizem diversas manipulações de PDF em C#. Elas geralmente oferecem versões de avaliação gratuitas para explorar os recursos, com licenças disponíveis para compra.

Como usar o loop while para iteração indexada em C#?

Em C#, é possível utilizar um laço while com uma variável de índice para iterar sobre coleções, permitindo o acesso tanto ao índice quanto ao elemento atual, utilizando o índice como subscrito.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim