O que é um loop foreach em C#?

O loop `foreach` em C# é uma construção de programação que simplifica o processo de iteração por coleções como arrays, listas e dicionários. Ele permite que os desenvolvedores realizem operações em cada item de uma coleção de forma concisa e legível, sem a necessidade de gerenciar índices ou contagens.

Como criar um relatório em PDF usando o loop foreach em C#?

Você pode usar o loop foreach em conjunto com o IronPDF para gerar relatórios em PDF. Ao iterar por uma coleção de dados, como uma lista de produtos, você pode criar dinamicamente uma string de relatório HTML e, em seguida, convertê-la em um PDF usando ChromePdfRenderer do IronPDF.

Quais são os casos de uso para o loop foreach em C#?

Os casos de uso comuns para o loop foreach incluem somar valores em uma coleção, pesquisar um item, modificar elementos e executar ações em cada elemento de uma coleção.

Qual a diferença entre o loop `foreach` e o loop `for` em C#?

O laço `foreach` é preferido devido à sua legibilidade e simplicidade. Ao contrário do laço `for`, ele não exige o gerenciamento manual do índice ou da contagem da coleção. O laço `foreach` é mais adequado para iterações somente leitura.

Como usar a palavra-chave `var` com o loop `foreach`?

Você pode usar a palavra-chave `var` no loop `foreach` para permitir que o compilador infira o tipo de dados dos elementos na coleção, tornando o código mais conciso e fácil de manter.

É possível modificar uma coleção enquanto se utiliza um loop foreach?

O laço `foreach` não é adequado para modificar uma coleção durante a iteração devido a possíveis erros de tempo de execução. Se a modificação for necessária, considere usar um laço `for` ou criar uma nova coleção modificada.

Como lidar com iterações de dicionário usando o loop foreach em C#?

Em C#, você pode iterar por dicionários usando o loop foreach, aproveitando a estrutura KeyValuePair para acessar tanto as chaves quanto os valores de forma eficiente.

Que tipos de coleções o loop foreach pode percorrer?

O loop foreach pode iterar através de qualquer coleção que implemente a interface IEnumerable ou IEnumerable. Isso inclui arrays, listas, dicionários e outros tipos de coleções em C#.

Qual é a sintaxe do loop foreach em C#?

A sintaxe do loop foreach em C# é: foreach (variableType variableName in collection) { // Code to execute for each item } onde variableType é o tipo de dados, variableName é a variável do loop e collection é a coleção que está sendo iterada.

Como instalar uma biblioteca PDF em um projeto C#?

O IronPDF pode ser instalado em um projeto C# adicionando o pacote NuGet IronPDF. As instruções de instalação estão disponíveis na documentação do IronPDF.

A biblioteca C# PDF

Explore IronPDF Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ATUALIZAÇÕES DO DESENVOLVEDOR

C# For Each (Como funciona para desenvolvedores)

Curtis Chau

Updated: 21 de abril de 2026

Neste tutorial, abordaremos o loop "foreach" em C#, uma ferramenta essencial para desenvolvedores. O foreach loop simplifica o processo de iterar por uma coleção, tornando mais fácil realizar operações em cada item sem se preocupar com os detalhes subjacentes. Vamos discutir a importância do foreach, seus casos de uso e como implementá-lo no seu código C#.

Introdução ao `foreach` Loop

O foreach loop é uma ferramenta poderosa para desenvolvedores iterarem coleções de maneira concisa e legível. Isso simplifica o código e reduz as chances de erros, pois não há necessidade de gerenciar manualmente o índice ou a contagem dos itens da coleção. Em termos de legibilidade e simplicidade, o foreach loop é frequentemente preferido em relação ao tradicional for loop.

Os casos de uso para foreach incluem:

Somando os valores em uma coleção
Procurar um item em uma coleção
Modificando elementos em uma coleção
Executar ações em cada elemento de uma coleção

Entendendo Coleções

Existem diferentes tipos de coleções em C# que são usadas para armazenar um grupo de itens em um único objeto. Isso inclui matrizes, listas, dicionários e muito mais. O foreach loop é uma ferramenta útil que pode ser usada com qualquer coleção que implemente a interface IEnumerable ou IEnumerable<t>.

Alguns tipos comuns de coleções incluem:

Arrays: Uma coleção de elementos de tamanho fixo com o mesmo tipo de dados.
Listas: Uma coleção dinâmica de elementos com o mesmo tipo de dados.
Dicionários: Uma coleção de pares chave-valor, onde cada chave é única.

O namespace System.Collections.Generic contém vários tipos para trabalhar com coleções.

Implementing the `foreach` statement in C#

Agora que temos uma compreensão básica das coleções e do foreach loop, vamos mergulhar na sintaxe e ver como funciona em C#.

Sintaxe do `foreach` Loop

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

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

Aqui, variableType representa o tipo de dados dos itens na coleção, variableName é o nome dado ao item atual no loop (variável de loop) e collection refere-se à coleção que você deseja iterar.

Exemplo

Vamos considerar um exemplo em que temos uma lista de números inteiros e queremos encontrar a soma de todos os elementos da lista.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 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 foreach 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;

class Program
{
    static void Main()
    {
        // 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 foreach loop
        foreach (int number in numbers)
        {
            sum += number;
        }

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

Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		' Create a list of integers
		Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}

		' Initialize a variable to store the sum
		Dim sum As Integer = 0

		' Iterate through the list using foreach loop
		For Each number As Integer In numbers
			sum += number
		Next number

		' Print the sum
		Console.WriteLine("The sum of the elements is: " & sum)
	End Sub
End Class

Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		' Create a list of integers
		Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}

		' Initialize a variable to store the sum
		Dim sum As Integer = 0

		' Iterate through the list using foreach loop
		For Each number As Integer In numbers
			sum += number
		Next number

		' Print the sum
		Console.WriteLine("The sum of the elements is: " & sum)
	End Sub
End Class

Saída

Quando o loop é executado, ele produz a seguinte saída.

The sum of the elements is: 15

The sum of the elements is: 15

Text

No exemplo acima, primeiro criamos uma lista de inteiros chamada numbers e inicializamos uma variável sum para armazenar a soma dos elementos. Então, usamos o foreach loop para iterar na lista e adicionar o valor de cada elemento à soma. Por fim, imprimimos a soma no console. Este método também pode ser adaptado para impressão ou operação em outras coleções de maneira semelhante.

Variações e Melhores Práticas

Agora que temos uma compreensão básica de como usar o foreach loop, vamos discutir algumas variações e melhores práticas.

Iteração somente leitura: O foreach loop é mais adequado para iteração somente leitura, pois modificar a coleção durante a iteração pode levar a resultados inesperados ou erros de tempo de execução. Se você precisar modificar a coleção durante a iteração, considere usar um loop for tradicional ou criar uma nova coleção com as modificações desejadas.

Usando a palavra-chave var: Em vez de especificar explicitamente o tipo de dado dos elementos na coleção, você pode usar a palavra-chave var para deixar o compilador inferir o tipo de dado. Isso pode tornar o código mais conciso e mais fácil de manter.

Exemplo:

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

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

Iteração através de dicionários: Ao usar um foreach loop para iterar através de dicionários, você precisará trabalhar com a estrutura KeyValuePair. Essa estrutura representa um par chave-valor em um dicionário.

Exemplo:

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

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 e foreach: LINQ (Language Integrated Query) é um recurso poderoso no C# que permite consultar e manipular dados de forma mais declarativa. Você pode usar LINQ com o foreach loop para criar código mais expressivo e eficiente.

Exemplo:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        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 foreach loop
        foreach (var number in evenNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        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 foreach loop
        foreach (var number in evenNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Linq

Friend Class Program
	Shared Sub Main()
		Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}

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

		' Iterate through the even numbers using foreach loop
		For Each number In evenNumbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class

Imports System
Imports System.Collections.Generic
Imports System.Linq

Friend Class Program
	Shared Sub Main()
		Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}

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

		' Iterate through the even numbers using foreach loop
		For Each number In evenNumbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class

Adicionando a funcionalidade do IronPDF ao tutorial C# `foreach`

Nesta seção, vamos expandir nosso tutorial sobre o loop "foreach" em C# apresentando o IronPDF, uma biblioteca popular para trabalhar com arquivos PDF em C#. Vamos demonstrar como usar o foreach loop em conjunto com o IronPDF para gerar um relatório PDF baseado em uma coleção de dados.

Introdução ao IronPDF

IronPDF é uma biblioteca poderosa para criar, editar e extrair conteúdo de arquivos PDF em C#. Ela oferece uma API fácil de usar para trabalhar com documentos PDF, tornando-se uma excelente opção para desenvolvedores que precisam incorporar a funcionalidade de PDF em seus aplicativos.

Algumas das principais funcionalidades do IronPDF incluem:

Geração de PDFs a partir de HTML, URLs e imagens
Edição de documentos PDF existentes
Extração de texto e imagens de PDFs
Adicionando anotações, campos de formulário e criptografia a PDFs

Instalando o IronPDF

Para começar a usar o IronPDF , você precisará instalar o pacote NuGet do IronPDF . Você pode fazer isso seguindo as instruções na documentação do IronPDF .

Gerando um Relatório PDF com IronPDF e `foreach`

Neste exemplo, usaremos a biblioteca IronPDF e o foreach loop para criar um relatório PDF de uma lista de produtos, incluindo seus nomes e preços.

Primeiro, vamos criar uma classe Product simples para representar os produtos:

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

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

Em seguida, vamos criar uma lista de objetos Product para gerar o relatório 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)
}

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)
}

Agora, podemos usar o IronPDF e o foreach loop para gerar um relatório PDF contendo as informações dos produtos:

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

class Program
{
    static void Main()
    {
        // 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 foreach 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;

class Program
{
    static void Main()
    {
        // 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 foreach 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

Friend Class Program
	Shared Sub Main()
		' Create a list of products
		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)
		}

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

		' Iterate through the list of products using foreach 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.")
	End Sub
End Class

Imports System
Imports System.Collections.Generic
Imports IronPdf

Friend Class Program
	Shared Sub Main()
		' Create a list of products
		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)
		}

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

		' Iterate through the list of products using foreach 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.")
	End Sub
End Class

C# For Each (Como Funciona Para Desenvolvedores) Figura 1 - Resultado da Saída

Conclusão

Ao longo deste tutorial, exploramos os fundamentos do loop "foreach" em C#, sua importância, casos de uso e como implementá-lo em seu código. Também introduzimos o IronPDF, uma biblioteca poderosa para trabalhar com arquivos PDF em C#, e demonstramos como usar o foreach loop em conjunto com o IronPDF para gerar um relatório PDF baseado em uma coleção de dados.

Continue aprendendo e desenvolvendo suas habilidades, e logo você poderá aproveitar todo o potencial do foreach loop e outras características do C# para criar aplicações robustas e eficientes. O IronPDF oferece um período de teste gratuito para experimentar a biblioteca. Se você decidir comprá-lo, a licença do IronPDF começa a partir de $999.

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 bem estruturados e visualmente atraentes.

...