In diesem Tutorial behandeln wir die "C# foreach"-Schleife, ein wesentliches Werkzeug für Entwickler. Die foreach-Schleife vereinfacht den Prozess des Durchlaufens durch eine Sammlung, sodass es einfacher ist, Operationen an jedem Element auszuführen, ohne sich um die zugrunde liegenden Details zu kümmern. Wir werden die Bedeutung von foreach, seine Anwendungsfälle und die Implementierung in Ihrem C#-Code besprechen.

Einführung in die foreach-Schleife

Die foreach-Schleife ist ein leistungsstarkes Werkzeug für Entwickler, um durch Sammlungen auf eine präzise und lesbare Weise zu iterieren. Sie vereinfacht den Code und verringert die Wahrscheinlichkeit von Fehlern, da es nicht erforderlich ist, den Index oder die Anzahl der Sammlungselemente manuell zu verwalten. In Bezug auf Lesbarkeit und Einfachheit wird die foreach-Schleife oft der traditionellen for-Schleife vorgezogen.

Anwendungsfälle für foreach umfassen:

• Summieren der Werte in einer Sammlung
• Suchen eines Elements in einer Sammlung
• Ändern von Elementen in einer Sammlung
• Ausführen von Aktionen auf jedem Element einer Sammlung

Sammlungen verstehen

Es gibt verschiedene Arten von Sammlungen in C#, die verwendet werden, um eine Gruppe von Elementen in einem einzigen Objekt zu speichern. Dazu gehören Arrays, Listen, Wörterbücher und mehr. Die foreach-Schleife ist ein nützliches Werkzeug, das mit jeder Sammlung verwendet werden kann, die die IEnumerable- oder IEnumerable<t>-Schnittstelle implementiert.

Einige häufige Sammlungstypen sind:

• Arrays: Eine Sammlung fester Größe von Elementen des gleichen Datentyps.
• Listen: Eine dynamische Sammlung von Elementen des gleichen Datentyps.
• Wörterbücher: Eine Sammlung von Schlüssel-Wert-Paaren, wobei jeder Schlüssel eindeutig ist.

Der System.Collections.Generic-Namensraum enthält verschiedene Typen für die Arbeit mit Sammlungen.

Implementing the foreach statement in C#

Da wir jetzt ein grundlegendes Verständnis von Sammlungen und der foreach-Schleife haben, lassen Sie uns in die Syntax eintauchen und sehen, wie sie in C# funktioniert.

Syntax der foreach-Schleife

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

Hier stellt variableType den Datentyp der Elemente in der Sammlung dar, variableName ist der Name des aktuellen Elements in der Schleife (Schleifenvariable) und collection bezieht sich auf die Sammlung, die Sie durchlaufen möchten.

Beispiel

Betrachten wir ein Beispiel, bei dem wir eine Liste von Ganzzahlen haben und die Summe aller Elemente in der Liste finden wollen.

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

Ausgabe

Wenn die Schleife ausgeführt wird, gibt sie folgendes Ergebnis aus.

The sum of the elements is: 15

The sum of the elements is: 15

Im obigen Beispiel erstellen wir zunächst eine Liste von ganzen Zahlen namens numbers und initialisieren eine Variable sum, um die Summe der Elemente zu speichern. Dann verwenden wir die foreach-Schleife, um die Liste zu durchlaufen und den Wert jedes Elements zur Summe hinzuzufügen. Schließlich geben wir die Summe auf der Konsole aus. Diese Methode kann auch angepasst werden, um andere Sammlungen ähnlich zu drucken oder zu bearbeiten.

Variationen und bewährte Praktiken

Da wir nun ein grundlegendes Verständnis dafür haben, wie die foreach-Schleife verwendet wird, lassen Sie uns einige Variationen und bewährte Praktiken diskutieren.

Nur-Lese-Iteration: Die foreach-Schleife eignet sich am besten für Nur-Lese-Iterationen, da das Ändern der Sammlung während der Iteration zu unerwarteten Ergebnissen oder Laufzeitfehlern führen kann. Wenn Sie die Sammlung während der Iteration ändern müssen, ziehen Sie in Betracht, eine traditionelle for-Schleife zu verwenden oder eine neue Sammlung mit den gewünschten Änderungen zu erstellen.

Verwendung des var-Schlüsselworts: Anstatt den Datentyp der Elemente in der Sammlung explizit anzugeben, können Sie das var-Schlüsselwort verwenden, um den Compiler den Datentyp ableiten zu lassen. Dies kann den Code prägnanter und pflegeleichter machen.

Beispiel:

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

Iterieren durch Wörterbücher: Beim Verwenden einer foreach-Schleife zum Durchlaufen von Wörterbüchern müssen Sie mit der KeyValuePair-Struktur arbeiten. Diese Struktur stellt ein Schlüssel-Wert-Paar in einem Wörterbuch dar.

Beispiel:

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 und foreach: LINQ (Language Integrated Query) ist ein leistungsstarkes Feature in C#, das es Ihnen ermöglicht, Daten auf eine deklarativere Weise abzufragen und zu manipulieren. Sie können LINQ mit der foreach-Schleife verwenden, um ausdrucksstärkeren und effizienteren Code zu erstellen.

Beispiel:

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

Hinzufügen von IronPDF-Funktionalität zum C# foreach-Tutorial

In diesem Abschnitt erweitern wir unser Tutorial zur "C# foreach"-Schleife, indem wir IronPDF vorstellen, eine beliebte Bibliothek zur Arbeit mit PDF-Dateien in C#. Wir werden zeigen, wie man die foreach-Schleife in Verbindung mit IronPDF verwendet, um einen PDF-Bericht zu erstellen, der auf einer Datensammlung basiert.

Einführung in IronPDF

IronPDF ist eine leistungsstarke Bibliothek zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dateien in C#. Sie bietet eine einfach zu verwendende API zur Arbeit mit PDF-Dokumenten und ist eine ausgezeichnete Wahl für Entwickler, die PDF-Funktionalität in ihre Anwendungen integrieren müssen.

Zu den wichtigsten Funktionen von IronPDF gehören:

• Generieren von PDFs aus HTML, URLs und Bildern
• Bearbeiten bestehender PDF-Dokumente
• Extrahieren von Text und Bildern aus PDFs
• Hinzufügen von Anmerkungen, Formularfeldern und Verschlüsselung zu PDFs

Installation von IronPDF

Um mit IronPDF zu beginnen, müssen Sie das IronPDF NuGet-Paket installieren. Sie können dies tun, indem Sie die Anweisungen in der IronPDF-Dokumentation befolgen.

Erstellen eines PDF-Berichts mit IronPDF und foreach

In diesem Beispiel werden wir die IronPDF-Bibliothek und die foreach-Schleife verwenden, um einen PDF-Bericht über eine Liste von Produkten zu erstellen, einschließlich ihrer Namen und Preise.

Lassen Sie uns zuerst eine einfache Product-Klasse erstellen, um die Produkte darzustellen:

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

Als nächstes erstellen wir eine Liste von Product-Objekten, um den PDF-Bericht zu erstellen:

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

Nun können wir IronPDF und die foreach-Schleife verwenden, um einen PDF-Bericht mit den Produktinformationen zu erstellen:

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

Abschluss

In diesem Tutorial haben wir die Grundlagen der "C# foreach"-Schleife, ihre Bedeutung, Anwendungsfälle und Implementierung in Ihrem Code untersucht. Wir haben auch IronPDF eingeführt, eine leistungsstarke Bibliothek zur Arbeit mit PDF-Dateien in C#, und gezeigt, wie man die foreach-Schleife in Verbindung mit IronPDF verwendet, um einen PDF-Bericht basierend auf einer Datensammlung zu erstellen.

Lernen Sie weiter und entwickeln Sie Ihre Fähigkeiten, und Sie werden bald in der Lage sein, das volle Potenzial der foreach-Schleife und anderer C#-Features zu nutzen, um robuste und effiziente Anwendungen zu erstellen. IronPDF bietet eine kostenlose Testversion zum Testen der Bibliothek an. Wenn Sie sich entscheiden, es zu kaufen, beginnt die IronPDF-Lizenz bei $999.