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

In diesem umfassenden Tutorial erfahren Sie alles, was Sie wissen müssen, um mit der for-Schleife in der Methode public static void Main zu beginnen. Wir werden uns mit for-Schleifen, Schleifenvariablen, Schleifenkörpern, Iterationsvariablen, inneren und äußeren Schleifen, Endlosschleifen, booleschen Ausdrücken, verschachtelten Schleifen und mehr beschäftigen. Fangen wir an!

Erste Schritte mit for-Schleifen

Eine "for"-Schleife ist eine Art von Schleife in C#, die speziell für Situationen entwickelt wurde, in denen Sie genau wissen, wie oft Sie iterieren wollen. Die Syntax für eine "for"-Schleife in C# ist in folgendem Codeblock dargestellt

    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 Schleifen- oder Iterationsvariable deklariert und initialisiert.

2. Bedingung: Ein boolescher/bedingter Ausdruck, der festlegt, ob die Schleife mit der mehrfachen Ausführung von Anweisungen fortfahren soll oder nicht.

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

Static Void Haupt- und Schleifenvariablen

In C# wird die Methode static void Main oder static void Main(Zeichenfolge []args) ist der Einstiegspunkt in Ihre 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 first for loop!");
            }
        }
    }

    using System;

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

Imports System

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

In diesem Beispiel wird die Schleifenvariable int i auf 0 initialisiert und dient 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.

Verschachtelte Schleife erforschen

Verschachtelte Schleifen sind Schleifen, die innerhalb anderer Schleifen angeordnet sind und eine innere und eine äußere Schleife mit Iteratorabschnitten bilden. Diese können bei der Arbeit mit mehrdimensionalen Datenstrukturen wie Matrizen nützlich sein, 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 innerer Schleife innerhalb der ä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 mit dem nächsten Wert von i fortfährt.

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 vorsichtig, wenn Sie Schleifen wie die while-Schleife oder die `foreach'-Schleife schreiben, um sicherzustellen, dass die Ausstiegsbedingung schließlich erfüllt wird. Es folgt ein Beispiel für eine Endlosschleife ohne festgelegte 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

Neben dem Standard für die Schleifenstruktur bietet C# auch Schleifensteuerungsanweisungen wie break und continue, mit denen Sie Ihre Schleifen effektiver verwalten können.

• Break: Diese Anweisung wird verwendet, um die Schleife sofort zu verlassen. Wenn eine Break-Anweisung angetroffen wird, wird die Schleife beendet und das Programm fährt mit der nächsten Codezeile außerhalb der Schleife fort.

• Fortsetzen: 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 zeigt:

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, wenn i den Wert 5 erreicht. Die Anweisung continue wird verwendet, um gerade Zahlen zu überspringen, so dass nur ungerade Zahlen kleiner als 5 gedruckt 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 "wahr" 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), **`

  ** (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 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 einzigen 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. Ist der Ausdruck false, wird die Schleife übersprungen, und das Programm fährt mit der nächsten Codezeile 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 so lange wiederholt, bis der boolesche Ausdruck false wird.

Integration von IronPDF zur Erstellung von Berichten mit For-Schleifen

IronPDF ist eine leistungsstarke Bibliothek zum Erzeugen, Bearbeiten und Rendern von PDFs in C#. 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

Sobald Sie IronPDF installiert haben, lassen Sie uns ein einfaches Beispiel erstellen, das eine PDF-Bericht aus HTML mit einer Tabelle von Zahlen und ihren Quadraten in einer for-Schleife.

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 Methode "GenerateReport" in Ihrer Datei Program.cs 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 kostenloser Test für Sie, um seine Fähigkeiten zu testen, und wenn Sie es nützlich finden, beginnt die Lizenzierung von $749.