Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# foreach
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

In diesem Tutorial behandeln wir die "C# foreach"-Schleife, ein wesentliches Werkzeug für Entwickler. Die foreach Schleife vereinfacht das Durchlaufen einer Sammlung und macht es einfacher, Operationen an jedem Element durchzuführen, ohne sich um die zugrunde liegenden Details kümmern zu müssen. 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 Sammlungen auf prägnante und lesbare Weise zu durchlaufen. 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. Hinsichtlich 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 Namespace System.Collections.Generic enthält verschiedene Typen für die Arbeit mit Sammlungen.

Die foreach-Anweisung in C# implementieren

Nachdem wir nun ein grundlegendes Verständnis von Sammlungen und der foreach Schleife haben, wollen wir uns die Syntax genauer ansehen und schauen, 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
$vbLabelText   $csharpLabel

Hierbei steht variableType für den Datentyp der Elemente in der Sammlung, 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
$vbLabelText   $csharpLabel

Ausgabe

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

The sum of the elements is: 15

Im obigen Beispiel erstellen wir zuerst eine Liste von ganzen Zahlen mit dem Namen numbers und initialisieren eine Variable sum, um die Summe der Elemente zu speichern. Anschließend 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

Nachdem wir nun ein grundlegendes Verständnis für die Verwendung der foreach Schleife haben, wollen wir einige Variationen und bewährte Vorgehensweisen besprechen.

Nur-Lese-Iteration: Die foreach Schleife eignet sich am besten für die Nur-Lese-Iteration, 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, sollten Sie eine herkömmliche for Schleife verwenden oder eine neue Sammlung mit den gewünschten Änderungen erstellen.

Verwendung des Schlüsselworts var: Anstatt den Datentyp der Elemente in der Sammlung explizit anzugeben, können Sie das Schlüsselwort var verwenden, damit der Compiler den Datentyp ableitet. 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
$vbLabelText   $csharpLabel

Iteration durch Wörterbücher: Wenn Sie eine foreach Schleife verwenden, um durch Wörterbücher zu iterieren, 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
$vbLabelText   $csharpLabel

LINQ und foreach: LINQ (Language Integrated Query) ist eine leistungsstarke Funktion in C#, die es Ihnen ermöglicht, Daten auf eine deklarativere Weise abzufragen und zu bearbeiten. 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
$vbLabelText   $csharpLabel

Hinzufügen der 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 demonstrieren, wie man die foreach Schleife in Verbindung mit IronPDF verwendet, um einen PDF-Bericht auf Basis einer Datensammlung zu generieren.

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 verwenden wir die IronPDF-Bibliothek und die foreach Schleife, um einen PDF-Bericht mit einer Liste von Produkten einschließlich ihrer Namen und Preise zu erstellen.

Zuerst erstellen wir eine einfache Product Klasse, 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
$vbLabelText   $csharpLabel

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

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

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

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# foreach (So funktioniert es für Entwickler) Abbildung 1 - Ausgaberesultat

Abschluss

In diesem Tutorial haben wir die Grundlagen der "C# foreach"-Schleife, ihre Bedeutung, Anwendungsfälle und Implementierung in Ihrem Code untersucht. Wir haben außerdem IronPDF vorgestellt, eine leistungsstarke Bibliothek für die Arbeit mit PDF-Dateien in C#, und demonstriert, wie man die foreach Schleife in Verbindung mit IronPDF verwendet, um einen PDF-Bericht auf Basis einer Datensammlung zu generieren.

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

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 über jede Sammlung iterieren, die das IEnumerable oder IEnumerable-Interface implementiert. Dazu gehören Arrays, Listen, Dictionaries 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.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

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

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an