In diesem umfassenden Tutorial werden wir alles abdecken, was Sie wissen müssen, um mit 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, geschachtelte Schleifen und mehr erkunden. Legen wir los!

Einstieg 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 untenstehenden Codeblock gezeigt:

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

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

initialization
Do While condition
	' Loop body
	increment
Loop

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 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 innerhalb 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

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 Variable. Die Schleife wird so lange ausgeführt, wie i kleiner als 5 ist. Nach jeder Iteration erhöht die Inkrement-Operation 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

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 iteriert dann durch 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 vorsichtig beim Schreiben von Schleifen wie while-Schleifen oder foreach-Schleifen, um sicherzustellen, dass die Austrittsbedingung letztendlich 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

' 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 Standardstruktur 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 auftritt, endet die Schleife und das Programm wird mit der nächsten Codezeile außerhalb der Schleife fortgesetzt.
• continue: Diese Anweisung wird verwendet, um den verbleibenden 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

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 5 erreicht. Die continue-Anweisung wird verwendet, um gerade Zahlen zu überspringen, sodass nur ungerade Zahlen, die kleiner als 5 sind, gedruckt 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 ist. Häufig verwendete boolesche Ausdrücke in vielen Schleifen umfassen:

• Comparisons: i < 10, i >= 10, i > 10, i == 10, i != 10
• Logical operators: && (AND), || (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

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 nicht gleich 5 ist.

Code-Blöcke und Schleifenkörper

Ein Codeblock ist eine Gruppe von Anweisungen, die in geschwungenen 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

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.

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 ist, wird die Schleife übersprungen und das Programm mit der nächsten Codezeile außerhalb der Schleife fortgesetzt.
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-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

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

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 GenerateReport-Methode aus Ihrer Program.cs-Datei auf:

GenerateReport();

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.