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

Pierwsze kroki z pętlami for

Pętla for to rodzaj pętli w C#, specjalnie zaprojektowanej do sytuacji, gdy dokładnie wiesz, ile razy chcesz iterować. Składnia pętli for w C# przedstawiona jest 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 C#, metoda static void Main lub static void Main(String []args) to punkt wejścia twojej aplikacji. W tym miejscu rozpoczyna się wykonywanie programu. Oto przykład pętli pokazujący, jak użyć pętli for wewnątrz metody 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 zainicjalizowana na 0 i działa jako zmienna. Pętla będzie kontynuować wykonywanie, dopóki i jest mniejsze od 5. Po każdej iteracji operacja inkrementacji 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 zewnętrzna pętla wykonuje się i zaczyna z i równym 0. Wewnętrzna pętla następnie iteruje przez wszystkie możliwe wartości j, zanim przejdzie do następnej 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. Bądź ostrożny, pisząc pętle takie jak pętle while lub 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, C# oferuje również instrukcje kontroli pętli, takie jak break i continue, które mogą pomóc efektywniej zarządzać pętlami.

• break: Ta instrukcja służy do natychmiastowego wyjścia z pętli. Gdy napotka się instrukcję break, pętla zostaje przerwana, a program kontynuuje z następną linią kodu poza pętlą.
• continue: Ta instrukcja jest używana do pominięcia pozostałego kodu w ciele pętli dla bieżącej iteracji i przejścia do następnej iteracji pętli.

Oto przykład demonstrują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 wykonywać się, gdy i osiąga 5. Instrukcja continue jest używana do pomijania liczb parzystych, więc tylko liczby nieparzyste mniejsze od 5 zostaną wydrukowane.

Wyrażenia boolowskie i warunki pętli

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

• Comparisons: i < 10, i >= 10, i > 10, i == 10, i != 10
• Operatory logiczne: && (AND), || (OR), ! (NOT)

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 się wykonywać, dopóki i jest mniejsze od 10 i nie jest równe 5.

Bloki kodu i treści pętli

Blok kodu to grupa instrukcji zamknięta w nawiasach klamrowych {}. 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 ciało pętli składa się z pojedynczego instrukcji Console.WriteLine, który drukuje aktualny 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 jest false, pętla jest pominięta, a program kontynuuje z następną linią kodu poza pętlą.
3. Jeśli wyrażenie jest true, ciało pętli jest wykonywane.
4. Zmienna pętli jest zwiększana lub aktualizowana.
5. Kroki 2-4 są powtarzane, dopóki wyrażenie logiczne nie stanie się 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 twojego 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.