Pętla For w języku C# (jak działa dla programistów)

Pierwsze kroki z pętlami for

Pętla for jest rodzajem pętli w języku C#, zaprojektowaną specjalnie na potrzeby sytuacji, w których dokładnie wiadomo, ile razy ma nastąpić iteracja. Składnia pętli for w języku C# została przedstawiona w poniższym bloku kodu:

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

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

initialization
Do While condition
	' Loop body
	increment
Loop

Przeanalizujmy składniki pętli for:

1. Inicjalizacja: W tym miejscu deklarowana i inicjalizowana jest zmienna pętli lub zmienna iteracji.
2. Warunek: Wyrażenie logiczne/warunkowe, które określa, czy pętla powinna kontynuować wielokrotne wykonywanie instrukcji, czy też nie.
3. Increment: To oświadczenie aktualizuje zmienną iteracji po każdej iteracji.

Zmienne statyczne typu void w pętlach i funkcji main

W języku C# metoda static void Main lub static void Main(String []args) stanowi punkt wejścia do aplikacji. W tym miejscu rozpoczyna się wykonywanie programu. Oto przykład pętli pokazujący, jak używać pętli for w metodzie 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

W tym przykładzie zmienna pętli int i jest inicjowana na 0 i pełni rolę zmiennej. Pętla będzie kontynuować wykonywanie tak długo, jak długo i jest mniejsze niż 5. Po każdej iteracji operacja przyrostowa i++ zwiększa wartość i o 1.

Odkrywanie zagnieżdżonych pętli

Pętle zagnieżdżone to pętle umieszczone wewnątrz innych pętli, tworzące pętlę wewnętrzną i zewnętrzną z sekcjami iteratora. Mogą one być przydatne podczas pracy ze strukturami danych wielowymiarowymi, takimi jak macierze, lub gdy konieczne jest wykonanie określonej operacji na każdej kombinacji elementów.

Oto przykład zagnieżdżonej pętli for z pętlą wewnętrzną wewnątrz pętli zewnętrznej w języku 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

W tym przykładzie pętla zewnętrzna jest wykonywana i rozpoczyna się od wartości i równej 0. Następnie pętla wewnętrzna iteruje przez wszystkie możliwe wartości j, zanim przejdzie do kolejnej wartości i.

Pętle nieskończone i kontrola pętli

Pętla nieskończona to pętla, która nigdy się nie kończy, ponieważ jej warunek nigdy nie staje się fałszywy. Może to być niebezpieczne, ponieważ może spowodować, że program zawiesi się na czas nieokreślony. Zachowaj ostrożność podczas pisania pętli, takich jak pętle while lub pętle foreach, aby upewnić się, że warunek wyjścia zostanie ostatecznie spełniony. Poniżej znajduje się przykład pętli nieskończonej bez określonego warunku w języku 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

Oprócz standardowej struktury pętli for, język C# udostępnia również instrukcje sterujące pętlami, takie jak break i continue, które mogą pomóc w bardziej efektywnym zarządzaniu pętlami.

• break: Ta instrukcja służy do natychmiastowego wyjścia z pętli. Po napotkaniu instrukcji break pętla zostaje zakończona, a program przechodzi do następnej linii kodu poza pętlą.
• continue: Ta instrukcja służy do pominięcia pozostałego kodu w treści pętli dla bieżącej iteracji i przejścia do następnej iteracji pętli.

Oto przykład ilustrujący użycie break i continue w pętli for:

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

W tym przykładzie pętla przestaje się wykonywać, gdy i osiąga 5. Instrukcja continue służy do pomijania liczb parzystych, więc wydrukowane zostaną tylko liczby nieparzyste mniejsze niż 5.

Wyrażenia boolowskie i warunki pętli

Warunek pętli to wyrażenie logiczne, które określa, czy pętla powinna kontynuować wykonywanie. Wyrażenie to jest oceniane przed każdą iteracją, a pętla zostanie uruchomiona tylko wtedy, gdy wyrażenie to wynosi true. Powszechnie stosowane wyrażenia boolowskie w wielu pętlach obejmują:

• Porównania: i < 10, i >= 10, i > 10, i == 10, i != 10
• Operatory logiczne: && (AND), || (OR), ! (NIE)

Można łączyć wiele wyrażeń za pomocą operatorów logicznych, aby tworzyć bardziej złożone warunki pętli. Na przykład:

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

W tym przykładzie pętla będzie wykonywana tak długo, jak długo i jest mniejsze od 10 i nie równe 5.

Bloki kodu i treści pętli

Blok kodu to grupa instrukcji ujętych w nawiasy klamrowe {}. W pętli for blok kodu następujący po deklaracji pętli nazywany jest treścią pętli. W tym miejscu umieścisz kod, który chcesz wykonać podczas każdej iteracji pętli.

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

W tym przykładzie treść pętli składa się z pojedynczego wyrażenia Console.WriteLine, które PRINTuje bieżący numer iteracji.

Kroki wykonywania pętli

Gdy w kodzie pojawia się pętla for, następuje następująca sekwencja zdarzeń:

1. Zmienna pętli jest inicjowana.
2. Wyrażenie boolowskie jest obliczane. Jeśli wyrażenie ma postać false, pętla jest pomijana, a program przechodzi do następnej linii kodu poza pętlą.
3. Jeśli wyrażenie ma postać true, wykonywana jest treść pętli.
4. Zmienna pętli jest zwiększana lub aktualizowana.
5. Kroki 2–4 są powtarzane, aż wyrażenie boolowskie przyjmie postać false.

Integracja IronPDF do generowania raportów za pomocą pętli For

Dowiedz się więcej o możliwościach generowania plików PDF w IronPDF, aby tworzyć dynamiczne i solidne raporty PDF w języku C#. Może to być przydatne narzędzie podczas pracy z pętlami for, zwłaszcza jeśli trzeba tworzyć dynamiczne raporty lub dokumenty na podstawie danych przetwarzanych w pętlach. W tej sekcji pokażemy, jak używać IronPDF w połączeniu z pętlami for w języku C# do generowania prostego raportu.

Najpierw musisz zainstalować pakiet IronPDF NuGet. Można to zrobić za pomocą konsoli menedżera pakietów w Visual Studio:

Install-Package IronPdf

Po zainstalowaniu IronPDF stwórzmy prosty przykład, który generuje raport PDF z HTML przy użyciu IronPDF, zawierający tabelę liczb i ich kwadratów przy użyciu pętli for.

Krok 1: Dodaj niezbędne przestrzenie nazw.

using IronPdf;
using System.IO;

using IronPdf;
using System.IO;

Imports IronPdf
Imports System.IO

Krok 2: Utwórz nową metodę o nazwie 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

Wywołaj metodę GenerateReport z pliku Program.cs:

GenerateReport();

GenerateReport();

GenerateReport()

Po uruchomieniu tego przykładu w katalogu wyjściowym aplikacji zostanie wygenerowany raport PDF o nazwie "NumberSquaresReport.pdf". Raport będzie zawierał tabelę liczb od 1 do 10 oraz ich kwadratów, wygenerowaną przy użyciu pętli for w języku C#.

Wnioski

Podsumowując, ten obszerny samouczek zapewnił Ci solidne podstawy dotyczące pętli for w języku C# i związanych z nimi pojęć. Omówiliśmy zmienne pętli, treści pętli, zmienne iteracji, pętle wewnętrzne i zewnętrzne, pętle nieskończone, wyrażenia boolowskie, bloki kodu, pętle zagnieżdżone, a nawet pokazaliśmy, jak zintegrować potężną bibliotekę IronPDF w celu generowania dynamicznych raportów PDF przy użyciu pętli for.

IronPDF oferuje bezpłatną wersję próbną IronPDF, dzięki której można przetestować jego możliwości, a jeśli uznasz go za przydatny, licencja jest dostępna w przystępnych cenach dostosowanych do Twoich potrzeb.