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

Einstieg mit for-Schleifen

Eine for Schleife ist eine Art Schleife in C#, die speziell für Situationen entwickelt wurde, in denen man genau weiß, wie oft man sie wiederholen möchte. Die Syntax für eine for Schleife in C# wird im folgenden Codeblock gezeigt:

for (initialization; condition; increment)
{
    // Loop body
}

for (initialization; condition; increment)
{
    // Loop body
}

initialization
Do While condition
	' Loop body
	increment
Loop

Lassen Sie uns die Komponenten einer For-Schleife aufschlüsseln:

1. Initialisierung: Hier wird die Schleifenvariable bzw. Iterationsvariable deklariert und initialisiert.
2. Bedingung: Ein boolescher/bedingter Ausdruck, der bestimmt, ob die Schleife Anweisungen mehrmals ausführen soll oder nicht.
3. Inkrement: Diese Anweisung aktualisiert die Iterationsvariable nach jeder Iteration.

Static Void Main und Schleifenvariablen

In C# ist die Methode static void Main oder static void Main(String []args) der Einstiegspunkt Ihrer Anwendung. Hier beginnt die Ausführung Ihres Programms. Hier ist ein Beispiel für die Verwendung einer for-Schleife innerhalb der Methode static void Main:

using System;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("This is the first for loop!");
        }
    }
}

using System;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("This is the first for loop!");
        }
    }
}

Imports System

Friend Class Program
	Shared Sub Main()
		For i As Integer = 0 To 4
			Console.WriteLine("This is the first for loop!")
		Next i
	End Sub
End Class

In diesem Beispiel wird die Schleifenvariable int i mit 0 initialisiert und fungiert als Variable. Die Schleife wird so lange ausgeführt, wie i kleiner als 5 ist. Nach jeder Iteration erhöht die Inkrementoperation i++ den Wert von i um 1.

Entdeckung verschachtelter Schleifen

Geschachtelte Schleifen sind Schleifen, die sich innerhalb anderer Schleifen befinden und eine innere und eine äußere Schleife mit Iterationsabschnitten bilden. Diese können nützlich sein, wenn Sie mit mehrdimensionalen Datenstrukturen wie Matrizen arbeiten oder eine bestimmte Operation auf jede Kombination von Elementen durchführen müssen.

Hier ist ein Beispiel für eine geschachtelte For-Schleife mit einer inneren Schleife innerhalb einer äußeren Schleife in C#:

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 2; j++)
    {
        Console.WriteLine($"i: {i}, j: {j}");
    }
}

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 2; j++)
    {
        Console.WriteLine($"i: {i}, j: {j}");
    }
}

For i As Integer = 0 To 2
	For j As Integer = 0 To 1
		Console.WriteLine($"i: {i}, j: {j}")
	Next j
Next i

In diesem Beispiel wird die äußere Schleife ausgeführt und beginnt mit i gleich 0. Die innere Schleife durchläuft dann alle möglichen Werte von j, bevor sie zum nächsten Wert von i übergeht.

Unendliche Schleifen und Schleifensteuerung

Eine Endlosschleife ist eine Schleife, die niemals endet, weil ihre Testbedingung niemals falsch wird. Diese können gefährlich sein, da sie Ihr Programm unendlich hängen lassen können. Seien Sie beim Schreiben von Schleifen wie z. B. while-Schleifen oder foreach-Schleifen vorsichtig, um sicherzustellen, dass die Abbruchbedingung schließlich erfüllt wird. Das Folgende ist ein Beispiel für eine Endlosschleife ohne angegebene Bedingung in C#.

// This is an example of an infinite loop
for (int i = 0; ; i++)
{
    Console.WriteLine("This loop will run forever!");
}

// This is an example of an infinite loop
for (int i = 0; ; i++)
{
    Console.WriteLine("This loop will run forever!");
}

' This is an example of an infinite loop
Dim i As Integer = 0
Do
	Console.WriteLine("This loop will run forever!")
	i += 1
Loop

Zusätzlich zur Standard-for-Schleifenstruktur bietet C# auch Schleifensteuerungsanweisungen wie break und continue, die Ihnen helfen können, Ihre Schleifen effektiver zu verwalten.

• break: Diese Anweisung dient zum sofortigen Verlassen der Schleife. Beim Auftreten einer break- Anweisung wird die Schleife beendet und das Programm mit der nächsten Codezeile außerhalb der Schleife fortgesetzt.
• continue: Diese Anweisung dient dazu, den restlichen Code im Schleifenkörper für die aktuelle Iteration zu überspringen und zur nächsten Iteration der Schleife zu springen.

Hier ist ein Beispiel, das die Verwendung von break und continue in einer for-Schleife demonstriert:

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break; // Exits the loop when i is equal to 5
    }

    if (i % 2 == 0)
    {
        continue; // Skips even numbers
    }

    Console.WriteLine($"Odd number: {i}");
}

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break; // Exits the loop when i is equal to 5
    }

    if (i % 2 == 0)
    {
        continue; // Skips even numbers
    }

    Console.WriteLine($"Odd number: {i}");
}

For i As Integer = 0 To 9
	If i = 5 Then
		Exit For ' Exits the loop when i is equal to 5
	End If

	If i Mod 2 = 0 Then
		Continue For ' Skips even numbers
	End If

	Console.WriteLine($"Odd number: {i}")
Next i

In diesem Beispiel wird die Schleife beendet, wenn i 5 erreicht. Die Anweisung continue dient dazu, gerade Zahlen zu überspringen, sodass nur ungerade Zahlen kleiner als 5 ausgegeben werden.

Boolesche Ausdrücke und Schleifenbedingungen

Die Schleifenbedingung ist ein boolescher Ausdruck, der bestimmt, ob die Schleife weiter ausgeführt werden soll. Dieser Ausdruck wird vor jeder Iteration ausgewertet, und die Schleife wird nur ausgeführt, wenn der Ausdruck true lautet. Häufig verwendete boolesche Ausdrücke in vielen Schleifen umfassen:

• Vergleiche: i < 10 , i >= 10 , i > 10 , i == 10 , i != 10
• Logische Operatoren: && (UND), || (OR), ! (NICHT)

Sie können mehrere Ausdrücke mit logischen Operatoren kombinieren, um komplexere Schleifenbedingungen zu erstellen. Zum Beispiel:

for (int i = 0; i < 10 && i != 5; i++)
{
    Console.WriteLine(i);
}

for (int i = 0; i < 10 && i != 5; i++)
{
    Console.WriteLine(i);
}

Dim i As Integer = 0
Do While i < 10 AndAlso i <> 5
	Console.WriteLine(i)
	i += 1
Loop

In diesem Beispiel wird die Schleife so lange ausgeführt, wie i kleiner als 10 und ungleich 5 ist.

Code-Blöcke und Schleifenkörper

Ein Codeblock ist eine Gruppe von Anweisungen, die in geschweiften Klammern eingeschlossen sind: {}. In einer For-Schleife wird der Codeblock, der auf die Schleifendeklaration folgt, als Schleifenkörper bezeichnet. Hier platzieren Sie den Code, den Sie während jeder Iteration der Schleife ausführen möchten.

for (int i = 0; i < 5; i++)
{
    // This is the loop body
    Console.WriteLine($"Iteration: {i}");
}

for (int i = 0; i < 5; i++)
{
    // This is the loop body
    Console.WriteLine($"Iteration: {i}");
}

For i As Integer = 0 To 4
	' This is the loop body
	Console.WriteLine($"Iteration: {i}")
Next i

In diesem Beispiel besteht der Schleifenkörper aus einer einzigen Console.WriteLine Anweisung, die die aktuelle Iterationsnummer ausgibt.

Schrittweise Schleifenausführung

Wenn eine For-Schleife in Ihrem Code gefunden wird, tritt die folgende Ereignisabfolge auf:

1. Die Schleifenvariable wird initialisiert.
2. Der boolesche Ausdruck wird ausgewertet. Wenn der Ausdruck false lautet, wird die Schleife übersprungen, und das Programm fährt mit der nächsten Codezeile außerhalb der Schleife fort.
3. Wenn der Ausdruck true lautet, wird der Schleifenkörper ausgeführt.
4. Die Schleifenvariable wird inkrementiert oder aktualisiert.
5. Die Schritte 2-4 werden wiederholt, bis der boolesche Ausdruck false lautet.

Integration von IronPDF zur Erstellung von Berichten mit For-Schleifen

Erfahren Sie mehr über die PDF-Generierungsfunktionen von IronPDF, um dynamische und robuste PDF-Berichte in C# zu erstellen. Es kann ein nützliches Werkzeug sein, wenn Sie mit For-Schleifen arbeiten, insbesondere wenn Sie dynamische Berichte oder Dokumente basierend auf den Daten in Ihren Schleifen erstellen müssen. In diesem Abschnitt zeigen wir Ihnen, wie Sie IronPDF in Verbindung mit C#-For-Schleifen verwenden, um einen einfachen Bericht zu erstellen.

Zunächst müssen Sie das IronPDF-NuGet-Paket installieren. Sie können dies mit der Paket-Manager-Konsole in Visual Studio tun:

Install-Package IronPdf

Sobald Sie IronPDF installiert haben, erstellen wir ein einfaches Beispiel, das einen PDF-Bericht aus HTML mit IronPDF generiert, der eine Tabelle von Zahlen und ihren Quadraten mit einer For-Schleife enthält.

Schritt 1: Fügen Sie die notwendigen Namespaces hinzu.

using IronPdf;
using System.IO;

using IronPdf;
using System.IO;

Imports IronPdf
Imports System.IO

Schritt 2: Erstellen Sie eine neue Methode namens GenerateReport.

static void GenerateReport()
{
    // Create an HTML template for the report
    var htmlTemplate = @"
    <html>
        <head>
            <style>
                table {
                    border-collapse: collapse;
                    width: 100%;
                }

                th, td {
                    border: 1px solid black;
                    padding: 8px;
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Number Squares Report</h1>
            <table>
                <thead>
                    <tr>
                        <th>Number</th>
                        <th>Square</th>
                    </tr>
                </thead>
                <tbody>
                    {0}
                </tbody>
            </table>
        </body>
    </html>";

    // Generate the table rows using a for loop
    string tableRows = "";
    for (int i = 1; i <= 10; i++)
    {
        tableRows += $"<tr><td>{i}</td><td>{i * i}</td></tr>";
    }

    // Insert the generated table rows into the HTML template
    string finalHtml = string.Format(htmlTemplate, tableRows);

    // Create a new PDF document from the HTML using IronPdf
    var pdf = new IronPdf.ChromePdfRenderer();
    var document = pdf.RenderHtmlAsPdf(finalHtml);

    // Save the PDF to a file
    document.SaveAs("NumberSquaresReport.pdf");
}

static void GenerateReport()
{
    // Create an HTML template for the report
    var htmlTemplate = @"
    <html>
        <head>
            <style>
                table {
                    border-collapse: collapse;
                    width: 100%;
                }

                th, td {
                    border: 1px solid black;
                    padding: 8px;
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Number Squares Report</h1>
            <table>
                <thead>
                    <tr>
                        <th>Number</th>
                        <th>Square</th>
                    </tr>
                </thead>
                <tbody>
                    {0}
                </tbody>
            </table>
        </body>
    </html>";

    // Generate the table rows using a for loop
    string tableRows = "";
    for (int i = 1; i <= 10; i++)
    {
        tableRows += $"<tr><td>{i}</td><td>{i * i}</td></tr>";
    }

    // Insert the generated table rows into the HTML template
    string finalHtml = string.Format(htmlTemplate, tableRows);

    // Create a new PDF document from the HTML using IronPdf
    var pdf = new IronPdf.ChromePdfRenderer();
    var document = pdf.RenderHtmlAsPdf(finalHtml);

    // Save the PDF to a file
    document.SaveAs("NumberSquaresReport.pdf");
}

Shared Sub GenerateReport()
	' Create an HTML template for the report
	Dim htmlTemplate = "
    <html>
        <head>
            <style>
                table {
                    border-collapse: collapse;
                    width: 100%;
                }

                th, td {
                    border: 1px solid black;
                    padding: 8px;
                    text-align: center;
                }
            </style>
        </head>
        <body>
            <h1>Number Squares Report</h1>
            <table>
                <thead>
                    <tr>
                        <th>Number</th>
                        <th>Square</th>
                    </tr>
                </thead>
                <tbody>
                    {0}
                </tbody>
            </table>
        </body>
    </html>"

	' Generate the table rows using a for loop
	Dim tableRows As String = ""
	For i As Integer = 1 To 10
		tableRows &= $"<tr><td>{i}</td><td>{i * i}</td></tr>"
	Next i

	' Insert the generated table rows into the HTML template
	Dim finalHtml As String = String.Format(htmlTemplate, tableRows)

	' Create a new PDF document from the HTML using IronPdf
	Dim pdf = New IronPdf.ChromePdfRenderer()
	Dim document = pdf.RenderHtmlAsPdf(finalHtml)

	' Save the PDF to a file
	document.SaveAs("NumberSquaresReport.pdf")
End Sub

Rufen Sie die Methode GenerateReport aus Ihrer Program.cs- Datei auf:

GenerateReport();

GenerateReport();

GenerateReport()

Wenn Sie dieses Beispiel ausführen, wird ein PDF-Bericht namens "NumberSquaresReport.pdf" im Ausgabeverzeichnis Ihrer Anwendung generiert. Der Bericht enthält eine Tabelle von Zahlen von 1 bis 10 und ihre Quadrate, die mit einer C#-For-Schleife erstellt wurden.

Abschluss

Abschließend hat Ihnen dieses umfassende Tutorial eine solide Grundlage in C#-For-Schleifen und den damit verbundenen Konzepten vermittelt. Wir haben Schleifenvariablen, Schleifenkörper, Iterationsvariablen, innere und äußere Schleifen, Endlosschleifen, boolesche Ausdrücke, Codeblöcke, geschachtelte Schleifen untersucht und sogar gezeigt, wie Sie die leistungsstarke IronPDF-Bibliothek integrieren können, um dynamische PDF-Berichte mit For-Schleifen zu erstellen.

IronPDF bietet eine kostenlose Testversion von IronPDF, damit Sie seine Fähigkeiten testen können, und wenn Sie es nützlich finden, beginnt die Lizenzierung mit erschwinglichen Optionen, die auf Ihre Bedürfnisse zugeschnitten sind.