Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# für jede
.NET HILFE

C# Für Jedes (Wie es für Entwickler funktioniert)

Curtis Chau
Curtis Chau
Aktualisiert:

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

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

Output

When the loop executes, it gives the following output.

The sum of the elements is: 15

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

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

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

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

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

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

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 $799.

Häufig gestellte Fragen

Was ist die C# foreach Schleife?

Die C# foreach Schleife ist ein Programmierkonstrukt, das den Prozess des Durchlaufens von Sammlungen wie Arrays, Listen und Wörterbüchern vereinfacht. Es erlaubt Entwicklern, Operationen an jedem Element einer Sammlung auf eine prägnante und lesbare Weise durchzuführen, ohne Indizes oder Zählungen verwalten zu müssen.

Wie kann man mit der foreach Schleife in C# einen PDF-Bericht erstellen?

Sie können die foreach Schleife in Kombination mit IronPDF verwenden, um PDF-Berichte zu erstellen. Durch das Durchlaufen einer Sammlung von Daten, wie einer Liste von Produkten, können Sie dynamisch einen HTML-Berichtsstring erstellen und dann in ein PDF umwandeln, indem Sie IronPDFs ChromePdfRenderer verwenden.

Was sind die Anwendungsfälle für die C# foreach Schleife?

Häufige Anwendungsfälle für die foreach Schleife umfassen das Summieren von Werten in einer Sammlung, das Suchen nach einem Element, das Modifizieren von Elementen und das Ausführen von Aktionen an jedem Element einer Sammlung.

Wie unterscheidet sich die foreach Schleife von der for Schleife in C#?

Die foreach Schleife wird wegen ihrer Lesbarkeit und Einfachheit bevorzugt. Im Gegensatz zur for Schleife erfordert sie keine manuelle Verwaltung des Index oder der Zählung der Sammlung. Die foreach Schleife wird am besten für Read-Only-Iterationen verwendet.

Wie verwendet man das var Schlüsselwort mit der foreach Schleife?

Sie können das var Schlüsselwort in der foreach Schleife verwenden, damit der Compiler den Datentyp der Elemente in der Sammlung ableitet, was den Code prägnanter und leichter wartbar macht.

Kann man eine Sammlung während der Verwendung einer foreach Schleife modifizieren?

Die foreach Schleife eignet sich nicht zum Modifizieren einer Sammlung während der Iteration aufgrund potenzieller Laufzeitfehler. Wenn eine Modifikation erforderlich ist, sollten Sie eine for Schleife verwenden oder eine neue modifizierte Sammlung erstellen.

Wie kann man Wörterbuch-Iterationen in C# mit der foreach Schleife handhaben?

In C# können Sie mit der foreach Schleife durch Wörterbücher iterieren, indem Sie die KeyValuePair Struktur verwenden, um effizient sowohl auf Schlüssel als auch auf Werte zuzugreifen.

Welche Arten von Sammlungen kann die foreach Schleife durchlaufen?

Die foreach Schleife kann jede Sammlung durchlaufen, die das IEnumerable oder IEnumerable Interface implementiert. Dazu gehören Arrays, Listen, Wörterbücher und andere Sammlungstypen in C#.

Was ist die Syntax der foreach Schleife in C#?

Die Syntax der foreach Schleife in C# lautet: foreach (variableType variableName in collection) { // Code zur Ausführung für jedes Element }, wobei variableType der Datentyp ist, variableName die Schleifenvariable und collection die Sammlung ist, die durchlaufen wird.

Wie installiert man eine PDF-Bibliothek in einem C# Projekt?

IronPDF kann in einem C# Projekt installiert werden, indem das IronPDF NuGet Paket hinzugefügt wird. Installationsanweisungen sind in der IronPDF-Dokumentation verfügbar.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion