Didn’t find what you were looking for?
Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# für jede
ENTWICKLER-UPDATES

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

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

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

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

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

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

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

C# For Each (Wie es für Entwickler funktioniert) 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 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.

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

Vereinfachen Sie das E-Invoicing mit IronPDFs neuem Update: PDF/A-3-Konformität und ZUGFeRD-Unterstützung
Aktualisiert

Vereinfachen Sie das E-Invoicing mit IronPDFs neuem Update: PDF/A-3-Konformität und ZUGFeRD-Unterstützung

Entdecken Sie, wie das neueste Update von IronPDF PDF/A-3-Konformität und ZUGFeRD-Unterstützung bietet, um Workflows zur E-Rechnungserstellung zu optimieren. Erfahren Sie, wie Unternehmen (insbesondere in europäischen Regionen) die Einhaltung von Vorschriften erreichen, die Rechnungserstellung automatisieren und ihre Abläufe mit diesem hybriden Dokumentenformat zukunftssicher machen können. Perfekt für die Erfüllung von EU-Rechnungsmandaten und mehr!

Weiterlesen
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