C# Continue (Comment ça marche pour les développeurs)

Introduction

Les instructions de flux de contrôle sont cruciales en programmation, car elles dictent la séquence d'exécution des instructions au sein d'un programme. En C#, trois instructions fondamentales pour contrôler les boucles sont 'continue', 'break' et 'goto'. Ces instructions permettent aux programmeurs de modifier le flux d'exécution à l'intérieur des boucles, ce qui améliore l'efficacité et la lisibilité du code. Dans cet article, nous plongeons dans les subtilités des méthodes continue et break en C#, en explorant leur syntaxe, leurs applications et les meilleures pratiques. Plus tard dans l'article, nous apprendrons également à connaître IronPDF - une bibliothèque PDF C# robuste de Iron Software pour lire et écrire des documents PDF.

Comprendre l'instruction 'continue;'

La déclaration continue est utilisée dans les structures de boucle pour sauter le bloc de code restant et passer à l'itération suivante de la boucle. Elle indique essentiellement au contrôle du programme de sauter le code restant de l'itération actuelle et de passer à l'itération suivante.

Syntaxe

continue;

continue;

continue

Exemple

public class Program
{
    public static void Main()
    {
        Console.WriteLine("Demonstrate Continue Method in C#");
        Console.WriteLine("Print 1 to 10 skip 5");
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                continue; // Skips iteration when i equals 5
            }
            Console.WriteLine(i);
        }
    }
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("Demonstrate Continue Method in C#");
        Console.WriteLine("Print 1 to 10 skip 5");
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                continue; // Skips iteration when i equals 5
            }
            Console.WriteLine(i);
        }
    }
}

Public Class Program
	Public Shared Sub Main()
		Console.WriteLine("Demonstrate Continue Method in C#")
		Console.WriteLine("Print 1 to 10 skip 5")
		For i As Integer = 0 To 9
			If i = 5 Then
				Continue For ' Skips iteration when i equals 5
			End If
			Console.WriteLine(i)
		Next i
	End Sub
End Class

Dans cet exemple, lorsque i est égal à 5, l'instruction continue est exécutée, passant le reste du code dans la boucle pour cette itération. Par conséquent, le nombre 5 ne sera pas imprimé et la boucle passe à l'itération suivante.

Sortie

Exploration de la méthode "break ;" (pause)

Contrairement à continue, l'instruction break est utilisée pour sortir prématurément d'une boucle. Lorsqu'elle est rencontrée, elle met fin à l'exécution de la boucle, quelle que soit la condition de la boucle. Il est généralement utilisé pour sortir d'une boucle, telle qu'une boucle while, avant qu'une certaine condition ne soit remplie.

Exemple

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
foreach (int number in numbers)
{
    if (number == 6)
    {
        break; // Exits loop when number equals 6
    }
    Console.WriteLine(number);
}

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
foreach (int number in numbers)
{
    if (number == 6)
    {
        break; // Exits loop when number equals 6
    }
    Console.WriteLine(number);
}

Dim numbers() As Integer = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
For Each number As Integer In numbers
	If number = 6 Then
		Exit For ' Exits loop when number equals 6
	End If
	Console.WriteLine(number)
Next number

Dans cet exemple, la boucle parcourt le tableau des nombres. Lorsqu'il rencontre le nombre 6, l'instruction break est exécutée, ce qui provoque l'arrêt prématuré de la boucle. Par conséquent, seuls les numéros 1 à 5 seront imprimés.

Explorez l'instruction 'goto';

La déclaration goto en C# offre un moyen de transférer le contrôle vers une étiquette spécifiée au sein de la même méthode, dans la même instruction switch, ou dans la même boucle. Bien que goto puisse être un outil puissant pour modifier le flux d'exécution vers des instructions de saut, il est souvent déconseillé dans les pratiques de programmation modernes en raison de son potentiel à rendre le code moins lisible et maintenable. Cependant, dans certaines situations, le goto peut être utilisé de manière efficace et sûre.

Syntaxe

La syntaxe de l'instruction goto en C# est simple :

goto label;

goto label;

GoTo label

Où l'étiquette est un identifiant suivi d'un deux-points (:), indiquant la position cible dans le code.

Exemple

Considérons un scénario dans lequel vous souhaitez quitter prématurément une boucle imbriquée lorsqu'une condition spécifique est remplie. Vous pouvez y parvenir à l'aide d'une instruction goto :

for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (i * j > 10)
        {
            goto exitLoop;
        }
        Console.WriteLine($"i: {i}, j: {j}");
    }
}
exitLoop:
Console.WriteLine("Exited the nested loop prematurely.");

for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (i * j > 10)
        {
            goto exitLoop;
        }
        Console.WriteLine($"i: {i}, j: {j}");
    }
}
exitLoop:
Console.WriteLine("Exited the nested loop prematurely.");

For i As Integer = 0 To 4
	For j As Integer = 0 To 4
		If i * j > 10 Then
			GoTo exitLoop
		End If
		Console.WriteLine($"i: {i}, j: {j}")
	Next j
Next i
exitLoop:
Console.WriteLine("Exited the nested loop prematurely.")

Dans cet exemple, l'instruction goto transfère le contrôle à l'étiquette exitLoop lorsque la condition i * j > 10 est remplie, sortant ainsi efficacement de la boucle imbriquée.

Présentation de IronPDF - Bibliothèque PDF complète de Iron Software.

IronPDF, développé par Iron Software, est une puissante bibliothèque PDF C# qui offre une solution tout-en-un pour travailler avec des PDFs dans des projets .NET. Que vous ayez besoin de créer, d'éditer, d'exporter, de sécuriser, de charger ou de manipuler des documents PDF, IronPDF vous couvre. Voici quelques caractéristiques et cas d'utilisation clés :

1. Conversion HTML en PDF : Convertissez le contenu HTML en format PDF de manière transparente. Vous pouvez générer des PDF à partir de HTML, MVC, ASPX et même d'images.

2. Signer, Modifier et Lire des PDF : Avec plus de 50 fonctionnalités, IronPDF vous permet de signer, modifier et extraire du contenu des fichiers PDF. Qu'il s'agisse d'ajouter des signatures numériques ou de modifier des PDF existants, IronPDF vous simplifie la tâche.

3. Prise en charge multiplateforme : IronPDF est conçu pour C#, F# et VB.NET, et fonctionne sur différentes versions de .NET, y compris .NET Core, .NET Standard et .NET Framework. Il est également disponible pour Java, Node.js et Python.

4. Compatibilité et environnements :

   • Versions .NET : Prend en charge C#, VB.NET et F#.

   • Types de projet : Fonctionne avec les applications web (Blazor & WebForms), de bureau (WPF & MAUI), et console.

   • Environnements d'application : Compatible avec Windows, Linux, Mac, Docker, Azure, AWS, et plus encore.

   • IDEs : S'intègre parfaitement avec Microsoft Visual Studio et JetBrains Rider.

   • Systèmes d'exploitation et processeurs : Fonctionne sur Windows, Mac et Linux (x64, x86, ARM).

5. Normes PDF et Édition :

   • Prend en charge diverses versions PDF (1.2 - 1.7), PDF/UA et PDF/A.

   • Définir les propriétés, la sécurité et la compression des fichiers PDF.

   • Modifier les métadonnées, l'historique des révisions et la structure du document.

   • Appliquer des modèles de page, des en-têtes, des pieds de page et des paramètres de page.

6. Optimisation des performances :

   • Prise en charge complète du multithreading et de l'asynchronisme pour une génération efficace de PDF.

   • Priorité à la précision, à la facilité d'utilisation et à la rapidité.

   Maintenant que nous connaissons la bibliothèque IronPDF, écrivons une application pour utiliser IronPDF et les instructions continue, break et goto.

Générer un document PDF à l'aide de la déclaration continue

Tout d'abord, créons une application console Visual Studio

Indiquer le nom et la localisation du projet.

Étape suivante, sélectionnez la version .NET requise et cliquez sur Créer.

Installez maintenant IronPDF en utilisant la commande ci-dessous.

dotnet add package IronPdf --version 2024.4.2

dotnet add package IronPdf --version 2024.4.2

Générons maintenant un document PDF à l'aide des instructions de contrôle.

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;
class Program
{
    public static async Task Main()
    {
        Console.WriteLine("Generate PDF document Using IronPDF");
        var htmlToPdf = new ChromePdfRenderer();
        var content = "<h1>Generate Numbers from 1 to 10, skip 5</h1>";
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                continue;
            }
            content += $"<p>{i}</p>";
        }
        content += "<h1>Generate Numbers from 1 to 10, stop at 7</h1>";
        for (int i = 0; i < 10; i++)
        {
            if (i == 7)
            {
                break;
            }
            content += $"<p>{i}</p>";
        }
        var pdf = htmlToPdf.RenderHtmlAsPdf(content);
        pdf.SaveAs("AwesomeIronPDF.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;
class Program
{
    public static async Task Main()
    {
        Console.WriteLine("Generate PDF document Using IronPDF");
        var htmlToPdf = new ChromePdfRenderer();
        var content = "<h1>Generate Numbers from 1 to 10, skip 5</h1>";
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                continue;
            }
            content += $"<p>{i}</p>";
        }
        content += "<h1>Generate Numbers from 1 to 10, stop at 7</h1>";
        for (int i = 0; i < 10; i++)
        {
            if (i == 7)
            {
                break;
            }
            content += $"<p>{i}</p>";
        }
        var pdf = htmlToPdf.RenderHtmlAsPdf(content);
        pdf.SaveAs("AwesomeIronPDF.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports System
Imports System.Threading.Tasks
Imports System.Diagnostics
Imports IronPdf
Friend Class Program
	Public Shared Async Function Main() As Task
		Console.WriteLine("Generate PDF document Using IronPDF")
		Dim htmlToPdf = New ChromePdfRenderer()
		Dim content = "<h1>Generate Numbers from 1 to 10, skip 5</h1>"
		For i As Integer = 0 To 9
			If i = 5 Then
				Continue For
			End If
			content &= $"<p>{i}</p>"
		Next i
		content &= "<h1>Generate Numbers from 1 to 10, stop at 7</h1>"
		For i As Integer = 0 To 9
			If i = 7 Then
				Exit For
			End If
			content &= $"<p>{i}</p>"
		Next i
		Dim pdf = htmlToPdf.RenderHtmlAsPdf(content)
		pdf.SaveAs("AwesomeIronPDF.pdf")
		Console.WriteLine("PDF generated successfully.")
	End Function
End Class

Explication du code

1. Au départ, nous créons du contenu destiné à être utilisé dans un document PDF.

2. Nous préparons le contenu sous forme de document HTML.

3. Nous utilisons l'instruction continue à l'intérieur de la boucle for pour imprimer de 1 à 10 et sauter 5.

4. Nous utilisons également l'instruction break pour afficher de 1 à 7 puis arrêter.

5. Nous utilisons ensuite l'objet ChromePdfRenderer pour enregistrer le document HTML dans un document PDF.

Sortie

Bonnes pratiques et considérations

1. Clarté et Lisibilité : Dans la plupart des cas, utiliser des instructions de contrôle de flux structurées comme break, continue ou des boucles imbriquées peut rendre votre code plus lisible et compréhensible. Les instructions goto peuvent rendre le code plus difficile à suivre, surtout pour les bases de code plus importantes ou lorsqu'elles sont utilisées de manière excessive.

2. Éviter les conséquences involontaires : Une mauvaise utilisation de goto peut conduire à un code spaghetti et rendre difficile la compréhension du comportement du programme. Il est essentiel d'utiliser goto avec discernement et de veiller à ce que son utilisation soit claire et bien documentée.

3. Gestion des erreurs : Un cas d'utilisation fréquent de goto est dans les scénarios de gestion des erreurs, où il peut être utilisé pour sauter à une routine de nettoyage ou de gestion des erreurs. Cependant, les bases de code C# modernes utilisent souvent la gestion structurée des exceptions (try-catch-finally) pour la gestion des erreurs, ce qui offre une approche plus structurée et lisible.

4. Considérations de Performances : En termes de performance, goto a généralement un impact minimal. Cependant, la préoccupation principale avec goto concerne la maintenabilité et la lisibilité plutôt que la performance.

Licence (version d'essai disponible)

Découvrez les détails des licences IronPDF.

Une licence d'essai de développeur est disponible Obtenez une licence d'essai.

Veuillez remplacer la clé dans le fichier appSettings.json indiqué ci-dessous.

{
  "IronPdf.License.LicenseKey": "The Key Here"
}

Conclusion

En conclusion, les méthodes continue et break sont des outils indispensables pour contrôler l'exécution de boucle en C#. En incorporant stratégiquement ces déclarations dans votre code, vous pouvez en améliorer l'efficacité, la lisibilité et la maintenabilité. Bien que l'instruction goto en C# fournisse un mécanisme pour modifier le flux d'exécution, son utilisation doit être abordée avec prudence. Dans la plupart des cas, les instructions de contrôle de flux structurées comme break, continue, ou les boucles imbriquées offrent des solutions plus claires et plus faciles à maintenir. Toutefois, il existe des scénarios particuliers dans lesquels goto peut être utilisé de manière efficace et sûre, par exemple dans certaines situations de traitement des erreurs. Comme pour toute construction de programmation, il est essentiel de peser les compromis et de tenir compte de la lisibilité et de la maintenabilité du code lorsque l'on décide d'utiliser ou non la méthode goto.

Avec la bibliothèque IronPDF - Comprehensive PDF Solutions de Iron Software pour lire et générer des documents PDF, les développeurs peuvent acquérir des compétences avancées pour développer des applications modernes.