Loop For em C# (Como funciona para desenvolvedores)

Introdução aos laços for

Um loop for é um tipo de loop em C#, projetado especificamente para situações em que você sabe exatamente quantas vezes deseja iterar. A sintaxe para um loop for em C# é mostrada no bloco de código abaixo:

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

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

initialization
Do While condition
	' Loop body
	increment
Loop

Vamos analisar os componentes de um laço for:

1. Inicialização: É aqui que a variável de loop, ou variável de iteração, é declarada e inicializada.
2. Condição: Uma expressão booleana/condicional que determina se o loop deve continuar executando instruções várias vezes ou não.
3. Incremento: Esta instrução atualiza a variável de iteração após cada iteração.

Variáveis ​​estáticas vazias para Main e Loop

Em C#, o método static void Main ou static void Main(String []args) é o ponto de entrada da sua aplicação. É aqui que seu programa começa a ser executado. Aqui está um exemplo de como usar um loop for dentro do método 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

Neste exemplo, a variável de loop int i é inicializada com 0 e atua como a variável. O loop continuará sendo executado enquanto i for menor que 5. Após cada iteração, a operação de incremento i++ aumenta o valor de i em 1.

Explorando Loops Aninhados

Laços aninhados são laços que são colocados dentro de outros laços, formando um laço interno e um laço externo com seções de iteradores. Essas funcionalidades podem ser úteis ao trabalhar com estruturas de dados multidimensionais, como matrizes, ou quando você precisa realizar uma determinada operação em cada combinação de elementos.

Aqui está um exemplo de um laço for aninhado com um laço interno dentro de um laço externo em 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

Neste exemplo, o loop externo é executado e começa com i igual a 0. O loop interno então itera por todos os valores possíveis de j antes de passar para o próximo valor de i.

Loops infinitos e controle de loops

Um loop infinito é um loop que nunca termina porque sua condição de teste nunca se torna falsa. Esses erros podem ser perigosos, pois podem fazer com que seu programa trave indefinidamente. Ao escrever loops como loops while ou loops foreach, tenha cuidado para garantir que a condição de saída seja eventualmente atendida. Segue abaixo um exemplo de um loop infinito sem condição especificada em 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

Além da estrutura de laço padrão for, o C# também fornece instruções de controle de laço, como break e continue, que podem ajudá-lo a gerenciar seus laços de forma mais eficaz.

• break: Esta instrução é usada para sair imediatamente do loop. Quando uma instrução break é encontrada, o loop termina e o programa continua com a próxima linha de código fora do loop.
• continue: Esta instrução é usada para ignorar o restante do código no corpo do loop para a iteração atual e pular para a próxima iteração do loop.

Aqui está um exemplo que demonstra o uso de break e continue em um loop 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

Neste exemplo, o loop para de executar quando i atinge 5. A instrução continue é usada para ignorar números pares, de modo que apenas números ímpares menores que 5 serão impressos.

Expressões booleanas e condições de loop

A condição do loop é uma expressão booleana que determina se o loop deve continuar a ser executado. Esta expressão é avaliada antes de cada iteração, e o loop só será executado se a expressão for true. Expressões booleanas comumente usadas em muitos loops incluem:

• Comparações: i < 10 , i >= 10 , i > 10 , i == 10 , i != 10
• Operadores lógicos: && (E), || (OU), ! (NÃO)

Você pode combinar várias expressões usando operadores lógicos para criar condições de loop mais complexas. Por exemplo:

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

Neste exemplo, o loop será executado enquanto i for menor que 10 e diferente de 5 .

Blocos de código e corpos de loop

Um bloco de código é um grupo de instruções delimitado por chaves {}. Em um laço for, o bloco de código que segue a declaração do laço é conhecido como corpo do laço. É aqui que você vai inserir o código que deseja executar durante cada iteração do loop.

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

Neste exemplo, o corpo do loop consiste em uma única instrução Console.WriteLine que imprime o número da iteração atual.

Etapas de execução do loop

Quando um laço for é encontrado em seu código, a seguinte sequência de eventos ocorre:

1. A variável de loop é inicializada.
2. A expressão booleana é avaliada. Se a expressão for false, o loop é ignorado e o programa continua com a próxima linha de código fora do loop.
3. Se a expressão for true, o corpo do loop será executado.
4. A variável de loop é incrementada ou atualizada.
5. Os passos 2 a 4 são repetidos até que a expressão booleana se torne false.

Integrando o IronPDF para gerar relatórios com loops For

Aprenda sobre os recursos de geração de PDF do IronPDF para criar relatórios PDF dinâmicos e robustos em C#. Pode ser uma ferramenta útil ao trabalhar com laços de repetição (for), especialmente se você precisar criar relatórios ou documentos dinâmicos com base nos dados processados ​​em seus laços. Nesta seção, mostraremos como usar o IronPDF em conjunto com loops for em C# para gerar um relatório simples.

Primeiro, você precisará instalar o pacote NuGet IronPDF . Você pode fazer isso usando o Console do Gerenciador de Pacotes no Visual Studio:

Install-Package IronPdf

Após instalar o IronPDF , vamos criar um exemplo simples que gera um relatório em PDF a partir de HTML , contendo uma tabela de números e seus quadrados, utilizando um laço for.

Passo 1: Adicione os namespaces necessários.

using IronPdf;
using System.IO;

using IronPdf;
using System.IO;

Imports IronPdf
Imports System.IO

Passo 2: Crie um novo método chamado 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

Chame o método GenerateReport do seu arquivo Program.cs :

GenerateReport();

GenerateReport();

GenerateReport()

Ao executar este exemplo, um relatório em PDF chamado "NumberSquaresReport.pdf" será gerado no diretório de saída do seu aplicativo. O relatório conterá uma tabela de números de 1 a 10 e seus quadrados, gerados usando um loop for em C#.

Conclusão

Em conclusão, este tutorial abrangente forneceu uma base sólida em laços for em C# e seus conceitos relacionados. Exploramos variáveis ​​de laço, corpos de laço, variáveis ​​de iteração, laços internos e externos, laços infinitos, expressões booleanas, blocos de código, laços aninhados e até demonstramos como integrar a poderosa biblioteca IronPDF para gerar relatórios PDF dinâmicos usando laços for.

A IronPDF oferece um IronPDF de teste gratuito para que você possa experimentar suas funcionalidades e, caso a considere útil, o licenciamento começa com opções acessíveis que se adequam às suas necessidades.