C# für jeden (Wie IT für Entwickler funktioniert)

In diesem Tutorial werden wir die "C# foreach"-Schleife behandeln, ein wichtiges Werkzeug für Entwickler. Die foreach-Schleife vereinfacht den Prozess des Durchlaufens einer Sammlung, wodurch es einfacher wird, Operationen für jedes Element auszuführen, ohne sich um die zugrunde liegenden Details kümmern zu müssen. Wir werden die Bedeutung von foreach besprechen, seine Anwendungsfälle und wie man es in ihrem C#-Code implementiert.

Einführung in die foreach-Schleife

Die foreach-Schleife ist ein mächtiges Werkzeug für Entwickler, um in einer prägnanten und lesbaren Weise durch Sammlungen zu iterieren. Es vereinfacht den Code und verringert die Fehlerwahrscheinlichkeit, da der Index oder die Anzahl der Sammlungselemente nicht manuell verwaltet werden muss. In Bezug auf die Variablendeklarationen hat die foreach-Schleife fünf Variablendeklarationen, während die for-Schleife nur drei Variablendeklarationen hat.

Anwendungsfälle für foreach sind unter anderem:

• Summierung von Werten in einer Sammlung
• Suche nach einem Element in einer Sammlung
• Ändern von Elementen in einer Sammlung
• Durchführen von Aktionen für jedes 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 vieles mehr. Die foreach-Schleife ist ein nützliches Werkzeug, das mit jeder Sammlung verwendet werden kann, die das IEnumerable- oder IEnumerable-Interface implementiert.

Einige gängige Sammlungsarten sind:

• Arrays: Eine Sammlung von Elementen mit fester Größe und gleichem Datentyp.
• Listen: Eine dynamische Sammlung von Elementen mit demselben Datentyp.

• Wörterbücher: Eine Sammlung von Schlüssel-Wert-Paaren, wobei jeder Schlüssel eindeutig ist.

  Der System.Collections.Generic-Namensraum enthält die ForEach Erweiterungsmethode, die mit allen eingebauten Sammlungsklassen verwendet werden kann.

Implementierung der foreach-Anweisung in C##

Nachdem wir nun ein grundlegendes Verständnis von Sammlungen und der for each-Schleife haben, wollen wir uns mit der Syntax beschäftigen und sehen, wie sie in C# funktioniert.

Syntax der For Each-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

Hier steht variableType für den Datentyp der Elemente in der Sammlung, variableName ist der Name, der dem aktuellen Element in der Schleife (Schleifenvariable) gegeben wird, und collection bezieht sich auf die Sammlung, durch die Sie iterieren möchten.

Beispiel

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

    using System;
    using System.Collections.Generic;

            // 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 for each 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;

            // 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 for each loop
            foreach (int number in numbers)
            {
                sum += number;
            }

            // Print the sum
            Console.WriteLine("The sum of the elements is: " + sum);

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ausgabe

Wenn die Schleife ausgeführt wird, gibt sie die folgende Ausgabe.

    The sum of the elements is: 15

    The sum of the elements is: 15

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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 eines jeden Elements zur Summe hinzuzufügen. Zum Schluss geben wir die Summe auf der Konsole aus. Wir können auch ein Array ausdrucken, indem wir die foreach-Schleife auf ähnliche Weise verwenden.

Variationen und bewährte Praktiken

Nachdem wir nun ein grundlegendes Verständnis für die Verwendung der for each-Schleife haben, wollen wir nun einige Variationen und bewährte Verfahren 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, sollten Sie eine traditionelle 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 var-Schlüsselwort verwenden, damit der Compiler den Datentyp ableiten kann. Dadurch kann der Code übersichtlicher und leichter zu pflegen werden.

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

Durchlaufen von Dictionaries: Wenn Sie eine foreach-Schleife verwenden, um durch Dictionaries 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

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

Beispiel:

    using System;
    using System.Collections.Generic;
    using System.Linq;
            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 for each loop
            foreach (var number in evenNumbers)
            {
                Console.WriteLine(number);
            }

    using System;
    using System.Collections.Generic;
    using System.Linq;
            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 for each loop
            foreach (var number in evenNumbers)
            {
                Console.WriteLine(number);
            }

Imports System
	Imports System.Collections.Generic
	Imports System.Linq
			Private numbers As New List(Of Integer) From {1, 2, 3, 4, 5}

			' Use LINQ to filter out even numbers
			Private evenNumbers = numbers.Where(Function(n) n Mod 2 = 0)

			' Iterate through the even numbers using for each loop
			For Each number In evenNumbers
				Console.WriteLine(number)
			Next number

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

In diesem Abschnitt werden wir unser Tutorial über die "C# for each"-Schleife erweitern, indem wir IronPDF vorstellen, eine beliebte Bibliothek für die Arbeit mit PDF-Dateien in C#. Wir werden demonstrieren, wie man die foreach-Schleife in Verbindung mit IronPDF verwendet, um einen PDF-Bericht auf der Grundlage einer Datensammlung zu erstellen.

Einführung von IronPDF

IronPDF-Dokumentation ist eine leistungsstarke Bibliothek zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dateien in C#. Es bietet eine benutzerfreundliche API für die Arbeit mit PDF-Dokumenten und ist damit eine ausgezeichnete Wahl für Entwickler, die PDF-Funktionen in ihre Anwendungen integrieren müssen.

Zu den wichtigsten Funktionen von IronPDF gehören:

• Erstellen von PDFs aus HTML, URLs und Bildern
• Bearbeiten vorhandener 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 arbeiten, müssen Sie das IronPDF NuGet-Paket installieren. Sie können dies tun, indem Sie die Anweisungen unter Installing IronPDF befolgen.

Erzeugen eines PDF-Berichts mit IronPDF und für jeden

In diesem Beispiel werden wir die IronPDF-Bibliothek und die for each-Schleife verwenden, um einen PDF-Bericht mit einer Liste von Produkten, einschließlich ihrer Namen und Preise, zu erstellen.

Zuerst erstellen wir eine einfache Produkt-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

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

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

    using System;
    using System.Collections.Generic;
    using IronPdf;

    // 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 for each 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;

    // 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 for each 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

	' Create a list of products
	Private 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
	Private htmlReport As String = "<table><tr><th>Product Name</th><th>Price</th></tr>"

	' Iterate through the list of products using for each 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.")

Schlussfolgerung

In diesem Lernprogramm haben wir die Grundlagen der "C# for each"-Schleife, ihre Bedeutung, Anwendungsfälle und ihre Implementierung in Ihrem Code untersucht. Wir haben auch IronPDF vorgestellt, eine leistungsstarke Bibliothek für die Arbeit mit PDF-Dateien in C#, und demonstriert, wie man die for each-Schleife in Verbindung mit IronPDF verwendet, um einen PDF-Bericht auf der Grundlage einer Datensammlung zu erstellen.

Wenn Sie weiter lernen und Ihre Fähigkeiten ausbauen, werden Sie bald in der Lage sein, das volle Potenzial der for each-Schleife und anderer C#-Funktionen 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 $749.