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 répondre à vos besoins en matière 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 impliquant IronPDF. Ce voyage a pour but non seulement de dévoiler ses mécanismes, mais aussi de 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. Elle est particulièrement utile lorsque l'on souhaite effectuer des actions différentes en fonction de la valeur d'une variable particulière.

Cela en fait une alternative parfaite aux instructions if-else lorsque le mot-clé/variable est au centre de l'attention, car cela améliore la lisibilité du code et sa capacité à être maintenu. Contrairement à une 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 au-dessus du code et 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 de commutation avec motifs (C# ; à partir de la version 7.0)

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# ; à partir de la version 8.0)

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. Voyons maintenant comment l'instruction switch peut être utilisé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 en utilisant les données de l'utilisateur.

Console Input:

Sortie PDF:

3.3. Exemple de facture

Dans cet exemple de déclaration de cas, nous allons créer une facture à l'aide de l'entrée de l'utilisateur et d'une instruction de commutation.

Console Input:

Sortie PDF:

4. Conclusion

En conclusion, l'instruction switch de C# se distingue comme un outil robuste de flux de contrôle qui offre aux développeurs une approche plus organisée et plus concise de la gestion de conditions multiples 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 par différents types, notamment les commutateurs simples, les blocs de commutation basés sur des motifs, les commutateurs 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#.

IronPDFpour en savoir plus sur la conversion de HTML en PDF, visitez le site suivant lien.