.NET-HILFE

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

Veröffentlicht 16. Mai 2023

Teilen Sie:

In diesem umfassenden Tutorial erfahren Sie alles, was Sie wissen müssen, um mit for-Schleifen innerhalb der Methode public static void Main 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. 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 im folgenden Codeblock dargestellt:

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

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

initialization
Do While condition
		' Loop body
	increment
Loop

VB C#

Schauen wir uns die Komponenten einer for-Schleife an:

Initialisierung: Hier wird die Schleifen- oder Iterationsvariable deklariert und initialisiert.
Bedingung: Ein boolescher/bedingter Ausdruck, der festlegt, ob die Schleife mit der mehrfachen Ausführung von Anweisungen fortfahren soll oder nicht.
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 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

VB C#

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 Schleifen erforschen

Verschachtelte Schleifen in C# sind Schleifen, die innerhalb anderer Schleifen angeordnet sind und eine innere und eine äußere Schleife mit Iteratorabschnitten bilden. 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

VB C#

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 beim Schreiben von Schleifen wie while-Schleifen oder foreach-Schleifen, um sicherzustellen, dass die Exit-Bedingung schließlich 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

VB C#

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

VB C#

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

VB C#

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

VB C#

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:

Die Schleifenvariable wird initialisiert.
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.
Wenn der Ausdruck true ist, wird der Schleifenkörper ausgeführt.
Die Schleifenvariable wird inkrementiert oder aktualisiert.
Die Schritte 2-4 werden so lange wiederholt, bis der boolesche Ausdruck false wird.

Integration von IronPDF zur Erstellung von Berichten mit For-Schleifen

Erfahren Sie mehr über die PDF-Erzeugungsfunktionen 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

Sobald Sie IronPDF installiert haben, lassen Sie uns ein einfaches Beispiel erstellen, das einePDF-Bericht aus HTML mit IronPDF 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

VB C#

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

VB C#

Rufen Sie die Methode "GenerateReport" in Ihrer Datei Program.cs auf:

GenerateReport();

GenerateReport();

GenerateReport()

VB C#

Zahlenquadrate Bericht von IronPDF

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 einekostenlose Testversion von IronPDF wir bieten Ihnen die Möglichkeit, das Programm zu testen, und wenn Sie es für nützlich halten, können Sie es zu erschwinglichen Preisen lizenzieren, die Ihren Bedürfnissen entsprechen.

< PREVIOUS
C# Wait For Seconds (Wie es für Entwickler funktioniert)

NÄCHSTES >
C# String Replace (Wie es für Entwickler funktioniert)