What is the purpose of the C# 'foreach' loop?

The C# 'foreach' loop is designed to iterate through a collection, simplifying the process of operating on each item without managing indexes or counts manually.

What collection types can 'foreach' iterate through?

The 'foreach' loop can iterate through any collection implementing the IEnumerable or IEnumerable interface, including arrays, lists, and dictionaries.

Why might developers prefer 'foreach' over a traditional 'for' loop?

Developers prefer 'foreach' for its conciseness and readability, reducing error chances since there's no need to manually manage collection indexes.

How can IronPDF be used in conjunction with the 'foreach' loop?

IronPDF can be used with the 'foreach' loop to generate PDF reports by iterating through data collections, as demonstrated with a product list in the tutorial.

What are some best practices for using the 'foreach' loop?

Best practices for 'foreach' loops include using it for read-only iterations and employing the 'var' keyword to infer data types more concisely.

Can you modify a collection while iterating with 'foreach'?

Modifying a collection while iterating with 'foreach' is not recommended as it can lead to unexpected results or errors. A traditional 'for' loop or creating a new collection is advised for such modifications.

How can you iterate through a dictionary using 'foreach'?

When iterating through dictionaries with 'foreach', you use the KeyValuePair structure to access keys and values.

What are some of the key features of IronPDF?

IronPDF offers features such as generating PDFs from HTML, editing existing PDFs, extracting content, and adding annotations, forms, or encryption.

How do you install IronPDF for use in C# projects?

IronPDF can be installed in C# projects by adding the IronPDF NuGet package, following the documentation for setup instructions.

What benefits does using LINQ with 'foreach' provide?

Using LINQ with 'foreach' allows more declarative data queries and manipulation, enhancing expressiveness and efficiency in code handling.

The C# PDF Library

Explore IronPDF Start Free Trial

HTML to PDF

Online Demo See All Code Examples

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

.NET HELP

C# For Each (How IT Works For Developers)

Jacob Mellor

Updated: April 21, 2026

In this tutorial, we will cover the "C# foreach" loop, an essential tool for developers. The foreach loop simplifies the process of iterating through a collection, making it easier to perform operations on each item without worrying about the underlying details. We will discuss the importance of foreach, its use cases, and how to implement it in your C# code.

Introduction to the `foreach` Loop

The foreach loop is a powerful tool for developers to iterate through collections in a concise and readable manner. It simplifies the code and reduces the chances of errors, as there is no need to manage the index or count of the collection items manually. In terms of readability and simplicity, the foreach loop is often preferred over the traditional for loop.

Use cases for foreach include:

Summing up values in a collection
Searching for an item in a collection
Modifying elements in a collection
Performing actions on each element of a collection

Understanding Collections

There are different types of collections in C# that are used to store a group of items in a single object. These include arrays, lists, dictionaries, and more. The foreach loop is a useful tool that can be used with any collection that implements the IEnumerable or IEnumerable<T> interface.

Some common collection types include:

Arrays: A fixed-size collection of elements with the same data type.
Lists: A dynamic collection of elements with the same data type.
Dictionaries: A collection of key-value pairs, where each key is unique.

The System.Collections.Generic namespace contains various types for working with collections.

Implementing the `foreach` statement in C#

Now that we have a basic understanding of collections and the foreach loop, let's dive into the syntax and see how it works in C#.

Syntax of `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

Here, variableType represents the data type of the items in the collection, variableName is the name given to the current item in the loop (loop variable), and collection refers to the collection that you want to iterate through.

Example

Let's consider an example where we have a list of integers, and we want to find the sum of all the elements in the list.

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

Output

When the loop executes, it gives the following output.

The sum of the elements is: 15

The sum of the elements is: 15

Text

In the example above, we first create a list of integers called numbers and initialize a variable sum to store the sum of the elements. Then, we use the foreach loop to iterate through the list and add the value of each element to the sum. Finally, we print the sum to the console. This method can also be adapted to print or operate on other collections similarly.

Variations and Best Practices

Now that we have a basic understanding of how to use the foreach loop, let's discuss some variations and best practices.

Read-only Iteration: The foreach loop is best suited for read-only iteration, as modifying the collection while iterating can lead to unexpected results or runtime errors. If you need to modify the collection during iteration, consider using a traditional for loop or creating a new collection with the desired modifications.

Using the var keyword: Instead of explicitly specifying the data type of the elements in the collection, you can use the var keyword to let the compiler infer the data type. This can make the code more concise and easier to maintain.

Example:

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

Iterating through dictionaries: When using a foreach loop to iterate through dictionaries, you'll need to work with the KeyValuePair structure. This structure represents a key-value pair in a dictionary.

Example:

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 and foreach: LINQ (Language Integrated Query) is a powerful feature in C# that allows you to query and manipulate data in a more declarative way. You can use LINQ with the foreach loop to create more expressive and efficient code.

Example:

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

Adding IronPDF Functionality to the C# `foreach` Tutorial

In this section, we will extend our tutorial on the "C# foreach" loop by introducing IronPDF, a popular library for working with PDF files in C#. We will demonstrate how to use the foreach loop in conjunction with IronPDF to generate a PDF report based on a collection of data.

Introduction of IronPDF

IronPDF is a powerful library for creating, editing, and extracting content from PDF files in C#. It provides an easy-to-use API for working with PDF documents, making it an excellent choice for developers who need to incorporate PDF functionality into their applications.

Some key features of IronPDF include:

Generating PDFs from HTML, URLs, and images
Editing existing PDF documents
Extracting text and images from PDFs
Adding annotations, form fields, and encryption to PDFs

Installing IronPDF

To get started with IronPDF, you'll need to install the IronPDF NuGet package. You can do this by following the instructions in the IronPDF documentation.

Generating a PDF Report with IronPDF and `foreach`

In this example, we will use the IronPDF library and the foreach loop to create a PDF report of a list of products, including their names and prices.

First, let's create a simple Product class to represent the products:

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

Next, let's create a list of Product objects to generate the PDF report:

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

Now, we can use IronPDF and the foreach loop to generate a PDF report containing the product information:

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 (How It Works For Developers) Figure 1 - Output Result

Conclusion

Throughout this tutorial, we have explored the fundamentals of the "C# foreach" loop, its importance, use cases, and how to implement it in your code. We also introduced IronPDF, a powerful library for working with PDF files in C#, and demonstrated how to use the foreach loop in conjunction with IronPDF to generate a PDF report based on a collection of data.

Keep learning and building your skills, and you'll soon be able to harness the full potential of the foreach loop and other C# features to create robust and efficient applications. IronPDF offers a free trial for testing the library. If you decide to buy it, the IronPDF license starts from $999.

Jacob Mellor

Chat with engineering team now

Chief Technology Officer

Jacob Mellor is Chief Technology Officer at Iron Software and a visionary engineer pioneering C# PDF technology. As the original developer behind Iron Software's core codebase, he has shaped the company's product architecture since its inception, transforming it alongside CEO Cameron Rimington into a 50+ person company serving NASA, Tesla, and global government agencies.

...