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

C# For Each (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

Neste tutorial, abordaremos o loop "foreach" em C#, uma ferramenta essencial para desenvolvedores. O loop foreach simplifica o processo de iteração 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 de foreach, seus casos de uso e como implementá-lo em seu código C#.

Introdução ao Loop foreach

O loop foreach é uma ferramenta poderosa para desenvolvedores iterarem por coleções de forma 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 loop foreach é frequentemente preferido ao loop tradicional for.

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 loop foreach é 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 de coleções e do loop foreach, vamos mergulhar na sintaxe e ver como funciona em C#.

Sintaxe do loop foreach

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

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

Saída

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

The sum of the elements is: 15

No exemplo acima, primeiro criamos uma lista de números inteiros chamada numbers e inicializamos uma variável sum para armazenar a soma dos elementos. Em seguida, usamos o loop foreach para iterar pela 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 loop foreach, vamos discutir algumas variações e boas práticas.

Iteração somente leitura: O loop foreach é 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 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 dados dos elementos na coleção, você pode usar a palavra-chave var para permitir que o compilador infira o tipo de dados. 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
$vbLabelText   $csharpLabel

Iterando por dicionários: Ao usar um loop foreach para iterar por 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
$vbLabelText   $csharpLabel

LINQ e foreach: LINQ (Language Integrated Query) é um recurso poderoso em C# que permite consultar e manipular dados de uma forma mais declarativa. Você pode usar LINQ com o loop foreach para criar um 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
$vbLabelText   $csharpLabel

Adicionando funcionalidade IronPDF ao tutorial em 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 loop foreach em conjunto com o IronPDF para gerar um relatório em PDF com base 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 em PDF com IronPDF e foreach

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

Primeiro, vamos criar uma classe simples Product 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
$vbLabelText   $csharpLabel

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

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

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

C# Para cada (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 apresentamos o IronPDF, uma biblioteca poderosa para trabalhar com arquivos PDF em C#, e demonstramos como usar o loop foreach em conjunto com o IronPDF para gerar um relatório em PDF com base em uma coleção de dados.

Continue aprendendo e aprimorando suas habilidades, e em breve você poderá aproveitar todo o potencial do loop foreach e de outros recursos do C# para criar aplicativos robustos 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 em $799.

Perguntas frequentes

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 por 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.

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