Déclaration de commutation C# (Comment cela fonctionne pour les développeurs)

Dans le vaste paysage des langages de programmation, l'amélioration de la lisibilité et de l'efficacité du code est primordiale, et le langage C# fait figure de pilier puisqu'il propose diverses constructions pour vous aider dans vos besoins de codage. Parmi son arsenal d'outils puissants, l'outil "Déclaration d'interrupteur C#"se démarque nettement. Ce guide complet en explore les subtilités nuancées au sein du langage C#. Nous nous pencherons sur ses multiples utilisations et éclairerons son application pratique par le biais d'un scénario du monde réel impliquantIronPDFla bibliothèque C# polyvalente pour la génération de PDF. Ce voyage vise non seulement à démêler ses mécanismes, mais aussi à souligner son importance dans le paysage plus large du développement C#.

1. Comprendre la déclaration de changement de fournisseur

L'instruction switch en C# est une instruction de flux de contrôle qui permet aux développeurs d'écrire un code plus propre et plus concis lorsqu'il s'agit de conditions multiples. Il est particulièrement utile lorsque vous souhaitez effectuer des actions différentes en fonction de la valeur d'une variable particulière.

La traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement, ce qui en fait une alternative parfaite aux instructions if-else lorsque le mot-clé/variable est au centre de l'attention, car elle améliore la lisibilité du code et sa capacité à être maintenu. Contrairement à l'instruction if-else, qui peut conduire à des structures imbriquées et à une complexité potentielle du code, l'instruction switch offre une alternative plus organisée. Elle est particulièrement utile lorsqu'on travaille avec une variable qui doit déclencher des actions distinctes en fonction de sa valeur.

Examinons maintenant de plus près le rôle de la rupture dans le contexte d'une instruction de commutation. En C#, l'instruction break est utilisée pour mettre fin à l'exécution d'un bloc de code associé à un cas particulier au sein du bloc de commutation. Lorsqu'un cas de correspondance ou de commutation correspond et que le bloc de code correspondant à ce cas est exécuté, l'instruction break est cruciale pour empêcher l'évaluation des cas suivants. Si vous souhaitez incorporer un comportement d'anticipation dans votre déclaration, vous devez utiliser la déclaration goto au lieu de break.

Voici la structure de base d'une instruction switch en C# :

switch (variable)
{
    case a:
        // Code to be executed if variable equals value1
        break;
    case c:
        // Code to be executed if variable equals value2
        break;
    // More cases can be added as needed
    default:
        // Default Case to be executed if none of the cases match
        break;
}

switch (variable)
{
    case a:
        // Code to be executed if variable equals value1
        break;
    case c:
        // Code to be executed if variable equals value2
        break;
    // More cases can be added as needed
    default:
        // Default Case to be executed if none of the cases match
        break;
}

Select Case variable
	Case a
		' Code to be executed if variable equals value1
	Case c
		' Code to be executed if variable equals value2
	' More cases can be added as needed
	Case Else
		' Default Case to be executed if none of the cases match
End Select

Explorons maintenant les différents types d'instructions de commutation et leurs cas d'utilisation.

2. Types d'instructions de commutation et leur utilisation

2.1. Déclaration de commutation simple

Il s'agit de la forme la plus élémentaire d'une déclaration de commutation. Il compare la variable à des valeurs constantes et exécute le bloc de code associé à la première valeur ou au premier cas correspondant. Si aucune correspondance n'est trouvée, le bloc de code par défaut est exécuté.

int day = 3;
switch (day)
{
    case 1:
        Console.WriteLine("Monday");
        break;
    case 2:
        Console.WriteLine("Tuesday");
        break;
    // More cases...
    default:
        Console.WriteLine("Invalid day");
        break;
}

int day = 3;
switch (day)
{
    case 1:
        Console.WriteLine("Monday");
        break;
    case 2:
        Console.WriteLine("Tuesday");
        break;
    // More cases...
    default:
        Console.WriteLine("Invalid day");
        break;
}

Dim day As Integer = 3
Select Case day
	Case 1
		Console.WriteLine("Monday")
	Case 2
		Console.WriteLine("Tuesday")
	' More cases...
	Case Else
		Console.WriteLine("Invalid day")
End Select

2.2. Déclaration Switch avec motifs(C# 7.0 et versions ultérieures)

C# 7.0 a introduit la correspondance des cas, ce qui a permis de créer une instruction de commutation plus expressive et plus souple. Une expression de correspondance de motifs peut inclure des motifs de type, des motifs de propriété et bien d'autres choses encore, ce qui rend le code encore plus lisible.

object obj = "Hello";
switch (obj)
{
    case string s:
        Console.WriteLine($"String of length {s.Length}");
        break;
    case int i:
        Console.WriteLine($"Integer: {i}");
        break;
    // More cases...
    default:
        Console.WriteLine("Other type");
        break;
}

object obj = "Hello";
switch (obj)
{
    case string s:
        Console.WriteLine($"String of length {s.Length}");
        break;
    case int i:
        Console.WriteLine($"Integer: {i}");
        break;
    // More cases...
    default:
        Console.WriteLine("Other type");
        break;
}

Dim obj As Object = "Hello"
Select Case obj
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case string s:
	Case String s
		Console.WriteLine($"String of length {s.Length}")
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case int i:
	Case Integer i
		Console.WriteLine($"Integer: {i}")
	' More cases...
	Case Else
		Console.WriteLine("Other type")
End Select

2.3. Expression du commutateur(C# 8.0 et versions ultérieures)

Dans C# 8.0, une nouvelle forme plus concise d'instruction de commutation est introduite sous la forme d'expressions de commutation. Ils peuvent être utilisés là où l'expression constante d'une valeur est nécessaire, ce qui rend le code plus court et plus élégant.

int day = 2;
string result = day switch
{
    1 => "Monday",
    2 => "Tuesday",
    // More cases...
    _ => "Invalid day"
};
Console.WriteLine(result);

int day = 2;
string result = day switch
{
    1 => "Monday",
    2 => "Tuesday",
    // More cases...
    _ => "Invalid day"
};
Console.WriteLine(result);

Dim day As Integer = 2
Dim tempVar As String
Select Case day
	Case 1
		tempVar = "Monday"
	Case 2
		tempVar = "Tuesday"
	' More cases...
	Case Else
		tempVar = "Invalid day"
End Select
Dim result As String = tempVar
Console.WriteLine(result)

Maintenant que nous avons une bonne compréhension des instructions de commutation, voyons comment elles peuvent être appliquées dans un scénario réel en utilisant IronPDF en C#.

3. Présentation d'IronPDF au C# ;

IronPDF est une bibliothèque C# populaire qui permet aux développeurs de générer et de manipuler facilement des documents PDF. Il simplifie les tâches liées à la création, à l'édition et au rendu des fichiers PDF. Explorons comment la déclaration d'interrupteur peut être employée avec IronPDF pour améliorer la fonctionnalité et l'organisation de votre codage.

3.1. Utilisation de Switch Statement avec IronPDF

Supposons que vous travailliez sur un système de gestion de documents dans lequel vous devez générer différents types de PDF en fonction du cas d'utilisation du contenu d'un document. Voici comment vous pouvez tirer parti de la déclaration d'interrupteur avec IronPDF :

using IronPdf;
using System;
class generatePDF {
    public static void Main(String [] args)
    {
        var renderer = new ChromePdfRenderer();
        string mystring = null;
        Console.WriteLine("Enter your input : ");
        Console.WriteLine("Enter 'I' for Invoice");
        Console.WriteLine("Enter 'R' for Report");
        mystring = Console.ReadLine();
        switch (mystring)
        {
            case "R":
                var pdf = renderer.RenderHtmlFileAsPdf("invoice.html");
                pdf.SaveAs("Report.pdf");
                break;
            case "I":
                var pdfi = renderer.RenderHtmlFileAsPdf("report.html");
                pdfi.SaveAs("Invoice.pdf");
                break;
        }
    }
}

using IronPdf;
using System;
class generatePDF {
    public static void Main(String [] args)
    {
        var renderer = new ChromePdfRenderer();
        string mystring = null;
        Console.WriteLine("Enter your input : ");
        Console.WriteLine("Enter 'I' for Invoice");
        Console.WriteLine("Enter 'R' for Report");
        mystring = Console.ReadLine();
        switch (mystring)
        {
            case "R":
                var pdf = renderer.RenderHtmlFileAsPdf("invoice.html");
                pdf.SaveAs("Report.pdf");
                break;
            case "I":
                var pdfi = renderer.RenderHtmlFileAsPdf("report.html");
                pdfi.SaveAs("Invoice.pdf");
                break;
        }
    }
}

Imports IronPdf
Imports System
Friend Class generatePDF
	Public Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim mystring As String = Nothing
		Console.WriteLine("Enter your input : ")
		Console.WriteLine("Enter 'I' for Invoice")
		Console.WriteLine("Enter 'R' for Report")
		mystring = Console.ReadLine()
		Select Case mystring
			Case "R"
				Dim pdf = renderer.RenderHtmlFileAsPdf("invoice.html")
				pdf.SaveAs("Report.pdf")
			Case "I"
				Dim pdfi = renderer.RenderHtmlFileAsPdf("report.html")
				pdfi.SaveAs("Invoice.pdf")
		End Select
	End Sub
End Class

Ce programme C# utilise la bibliothèque IronPDF pour générer dynamiquement des fichiers PDF en fonction des données saisies par l'utilisateur. L'utilisateur est invité à saisir soit "I" pour Facture, soit "R" pour Rapport. En fonction de l'entrée, le programme utilise la classe ChromePdfRenderer pour rendre le fichier HTML correspondant("invoice.html" pour le rapport ou "report.html" pour la facture) au format PDF. Le PDF généré est ensuite enregistré avec les noms de fichiers appropriés, "Report.pdf" pour le rapport et "Invoice.pdf" pour la facture. Cette approche offre un moyen flexible et interactif de générer des types spécifiques de documents PDF par le biais d'une interface de console.

3.2. Exemple de rapport

Dans l'exemple suivant, nous allons créer un rapport à partir des données fournies par l'utilisateur.

Console Input:

Sortie PDF:

3.3. Exemple de facture

Dans cet exemple d'énoncé de cas, nous allons créer une facture en utilisant les données de l'utilisateur et une instruction de commutation.

Console Input:

Sortie PDF:

4. Conclusion

En conclusion, l'instruction switch en C# se distingue comme un outil de flux de contrôle robuste qui offre aux développeurs une approche plus organisée et concise pour gérer plusieurs conditions par rapport aux instructions if-else traditionnelles. En catégorisant l'exécution du code en fonction des valeurs des variables, les instructions de commutation peuvent contribuer à votre codage en améliorant la lisibilité et la maintenabilité.

La polyvalence des instructions de commutation est démontrée à travers différents types, notamment les commutateurs simples, les blocs de commutation basés sur des motifs et les expressions de commutation, chacun répondant à des scénarios de codage spécifiques.

L'intégration de la bibliothèque IronPDF illustre l'application pratique des instructions de commutation dans la génération de documents PDF dynamiques en fonction des entrées de l'utilisateur et montre comment cette fonctionnalité peut être exploitée dans des scénarios réels pour améliorer la flexibilité et l'efficacité de votre codage C#.

Pour explorer les capacités deIronPDF pour en savoir plus sur la conversion de HTML en PDF, visitez le site web de la Commission européenneTutoriels IronPDF.