C# For Loop (Wie es für Entwickler funktioniert)

In diesem umfassenden Tutorial behandeln wir alles, was Sie wissen müssen, um mit for-Schleifen innerhalb der public static void Main-Methode zu beginnen. Wir werden for-Schleifen, Schleifenvariablen, Schleifenkörper, Iterationsvariablen, innere und äußere Schleifen, Endlosschleifen, boolesche Ausdrücke, verschachtelte Schleifen und vieles mehr untersuchen. Lass uns beginnen!

Erste Schritte mit for-Schleifen

Eine for-Schleife ist eine Art Schleife in C#, die speziell für Situationen entwickelt wurde, in denen Sie genau wissen, wie oft Sie iterieren möchten. 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

Schauen wir uns die Komponenten einer for-Schleife an:

1. Initialisierung: Hier wird die Schleifenvariable oder Iterationsvariable deklariert und initialisiert.

2. Bedingung: Ein boolescher/konditionaler Ausdruck, der bestimmt, ob die Schleife mehrfach Anweisungen ausführen soll oder nicht.

3. Inkrement: Diese Anweisung aktualisiert die Iterationsvariable nach jeder Iteration.

Static Void Haupt- und Schleifenvariablen

In C# ist die static void Main-Methode oder static void Main(String []args) der Einstiegspunkt Ihrer Anwendung. Hier beginnt die Ausführung Ihres Programms. Hier ist ein Schleifenbeispiel, wie man eine for-Schleife in der static void Main-Methode verwendet:

    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 auf 0 initialisiert und fungiert als die Variable. Die Schleife wird fortgesetzt, solange i kleiner als 5 ist. Nach jeder Iteration erhöht die Inkrementoperation i++ den Wert von i um 1.

Verschachtelte Schleifen erforschen

Verschachtelte Schleifen in C# sind Schleifen, die innerhalb anderer Schleifen platziert sind, wodurch eine innere Schleife und eine äußere Schleife mit Iterator-Sektionen gebildet werden. Diese können nützlich sein, wenn Sie mit mehrdimensionalen Datenstrukturen wie Matrizen arbeiten oder wenn Sie eine bestimmte Operation für jede Kombination von Elementen durchführen müssen.

Hier ist ein Beispiel für eine verschachtelte 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 dazu führen können, dass Ihr Programm auf unbestimmte Zeit hängen bleibt. Seien Sie beim Schreiben von Schleifen wie while-Schleifen oder foreach-Schleifen vorsichtig, um sicherzustellen, dass die Abbruchbedingung letztendlich erfüllt wird. Es folgt ein Beispiel für eine Endlosschleife ohne bestimmte 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 zu der Standard-Struktur der for-Schleife bietet C# auch Schleifenkontrollanweisungen wie break und continue, die Ihnen helfen können, Ihre Schleifen effektiver zu verwalten.

• break: Diese Anweisung wird verwendet, um die Schleife sofort zu verlassen. Wenn eine break-Anweisung erreicht wird, endet die Schleife, und das Programm setzt mit der nächsten Codezeile außerhalb der Schleife fort.

• continue: Diese Anweisung wird verwendet, um 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 hört die Schleife auf zu laufen, wenn i den Wert 5 erreicht. Die continue-Anweisung wird verwendet, um gerade Zahlen zu überspringen, sodass nur ungerade Zahlen kleiner als 5 ausgegeben werden.

Boolesche Ausdrücke und Schleifenbedingungen

Die Schleifenbedingung ist ein Boolescher Wert, 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 ist. Zu den häufig verwendeten booleschen Ausdrücken in vielen Schleifen gehören:

• Vergleiche: i < 10, i >= 10, i >= 10, i == 10, i != 10

• Logische Operatoren: && (UND), **

  ** (ODER), **!`** (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 ausgeführt, solange i kleiner als 10 und nicht gleich 5 ist.

Codeblöcke und Schleifenkörper

Ein Codeblock ist eine Gruppe von Anweisungen, die in geschweifte 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 bei 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 einzelnen Console.WriteLine-Anweisung, die die aktuelle Iterationsnummer ausgibt.

Schritte zur Ausführung der Schleife

Wenn Sie in Ihrem Code auf eine for-Schleife stoßen, tritt die folgende Abfolge von Ereignissen ein:

1. Die Schleifenvariable wird initialisiert.

2. Der boolesche Ausdruck wird ausgewertet. Wenn der Ausdruck false ist, wird die Schleife übersprungen und das Programm setzt mit der nächsten Zeile Code außerhalb der Schleife fort.

3. Wenn der Ausdruck true ist, 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 wird.

Integration von IronPDF zur Erstellung von Berichten mit For-Schleifen

Erfahren Sie mehr über die PDF-Generierungsmöglichkeiten von IronPDF, um dynamische und robuste PDF-Berichte in C# zu erstellen. Es kann ein nützliches Werkzeug bei der Arbeit mit for-Schleifen sein, insbesondere wenn Sie dynamische Berichte oder Dokumente auf der Grundlage der in Ihren Schleifen verarbeiteten Daten erstellen müssen. In diesem Abschnitt zeigen wir Ihnen, wie Sie IronPDF in Verbindung mit C# for-Schleifen verwenden können, um einen einfachen Bericht zu erstellen.

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

    Install-Package IronPDF

    Install-Package IronPDF

Sobald Sie IronPDF installiert haben, lassen Sie uns ein einfaches Beispiel erstellen, das einen PDF-Bericht aus HTML mit IronPDF generiert, der eine Tabelle mit Zahlen und deren Quadraten unter Verwendung einer for-Schleife enthält.

Schritt 1: Fügen Sie die erforderlichen 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 two variables
    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 two variables
    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 two variables
	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 GenerateReport-Methode aus Ihrer Program.cs-Datei auf:

GenerateReport();

GenerateReport();

GenerateReport()

Wenn Sie dieses Beispiel ausführen, wird ein PDF-Bericht mit dem Namen "NumberSquaresReport.pdf" im Ausgabeverzeichnis Ihrer Anwendung erstellt. Der Bericht enthält eine Tabelle mit den Zahlen von 1 bis 10 und ihren Quadraten, die mit Hilfe einer C# for-Schleife erstellt wird.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass dieses umfassende Tutorial Ihnen eine solide Grundlage in C# für Schleifen und die damit verbundenen Konzepte vermittelt hat. Wir haben uns mit Schleifenvariablen, Schleifenkörpern, Iterationsvariablen, inneren und äußeren Schleifen, Endlosschleifen, booleschen Ausdrücken, Codeblöcken und verschachtelten Schleifen beschäftigt und sogar gezeigt, wie man die leistungsstarke IronPDF-Bibliothek integriert, um mit for-Schleifen dynamische PDF-Berichte zu erzeugen.

IronPDF bietet eine kostenlose Testversion von IronPDF an, 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.