C# subit une évolution continue, incorporant des fonctionnalités qui élèvent l'expressivité du langage et améliorent l'expérience globale du développeur. Parmi ces fonctionnalités, l'expression switch est particulièrement remarquable, servant d'outil puissant et succinct pour gérer plusieurs conditions au sein d'une seule expression.

Cette exploration approfondie plonge dans les complexités de l'expression switch en C#, fournissant des exemples qui mettent en avant sa syntaxe, ses applications et ses avantages.

De la correspondance de modèle et les valeurs constantes aux modèles de type et à l'utilisation de mots-clés comme "switch" et "case", nous naviguons à travers les divers éléments de cette fonctionnalité linguistique. La discussion englobe divers motifs, tels que les motifs constants, les motifs relationnels et les motifs de type, élucidant leurs rôles dans le contexte de l'expression switch.

De plus, nous examinons l'incorporation des expressions switch dans des scénarios réels, montrant leur utilité et offrant une clarté sur leur syntaxe et leur mise en œuvre. Pour plus de connaissances internes sur les expressions switch, visitez cette documentation Microsoft sur les expressions switch en C#.

Dans cet article, nous passerons en revue les exemples d'expressions switch et testerons leur cas d'utilisation à l'aide de la bibliothèque PDF IronPDF C#.

1. Introduction à l'expression Switch

L'expression switch, introduite dans C# 8.0, représente un changement de paradigme dans la façon dont les développeurs gèrent la logique conditionnelle. Traditionnellement, l'instruction switch était le choix incontournable pour le branchement basé sur différentes valeurs, mais elle avait des limitations en termes de verbosité et de flexibilité lorsque les mots-clés étaient utilisés. L'expression switch répond à ces préoccupations en fournissant une syntaxe concise qui permet un code plus expressif et fonctionnel.

Dans sa forme la plus simple, l'expression switch ressemble à une instruction switch traditionnelle mais est plus polyvalente. Elle évalue une expression et sélectionne une branche en fonction de la valeur de cette expression. Ce changement de paradigme permet aux développeurs d'écrire un code plus propre, plus lisible avec un modèle réduit.

2. Syntaxe et Utilisation de Base

La syntaxe de l'expression switch en C# est intuitive, ce qui facilite son adoption pour les développeurs familiers avec les instructions switch traditionnelles. Voici un exemple de base:

string result = input switch
{
    "case1" => "Result for case 1",
    "case2" => "Result for case 2",
    _ => "Default result for case label"
};

string result = input switch
{
    "case1" => "Result for case 1",
    "case2" => "Result for case 2",
    _ => "Default result for case label"
};

Dim tempVar As String
Select Case input
	Case "case1"
		tempVar = "Result for case 1"
	Case "case2"
		tempVar = "Result for case 2"
	Case Else
		tempVar = "Default result for case label"
End Select
Dim result As String = tempVar

Dim tempVar As String
Select Case input
	Case "case1"
		tempVar = "Result for case 1"
	Case "case2"
		tempVar = "Result for case 2"
	Case Else
		tempVar = "Default result for case label"
End Select
Dim result As String = tempVar

Dans cet exemple, la variable input est évaluée par rapport à plusieurs cas. Si le motif correspond à l'un des cas spécifiés, le résultat correspondant est affecté à la variable result. Le trait de soulignement (_) représente le cas optionnel par défaut, similaire au mot-clé default dans une instruction switch traditionnelle.

L'expression switch prend en charge une large gamme de modèles, y compris les modèles constants, les modèles de type, les modèles relationnels, et plus encore, ce qui en fait un outil polyvalent pour gérer des scénarios complexes. Elle peut être particulièrement utile lorsqu'il s'agit de gérer des énumérations, évitant ainsi le besoin de déclarations case répétitives.

3. Modèles Avancés et Déconstruction

L'un des points forts de l'expression switch réside dans sa capacité à travailler avec des modèles avancés et la déconstruction. Cela permet aux développeurs d'extraire des valeurs d'objets, de tableaux et de modèles de manière concise. Considérez l'exemple suivant d'une expression switch :

var result = shape switch
{
    Circle c => $"Circle with radius {c.Radius}",
    Rectangle r => $"Rectangle with dimensions {r.Length}x{r.Width}",
    _ => "Unknown shape"
};

var result = shape switch
{
    Circle c => $"Circle with radius {c.Radius}",
    Rectangle r => $"Rectangle with dimensions {r.Length}x{r.Width}",
    _ => "Unknown shape"
};

'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'var result = shape switch
'{
'	Circle c => $"Circle with radius {c.Radius}",
'	Rectangle r => $"Rectangle with dimensions {r.Length}x{r.Width}",
'	_ => "Unknown shape"
'};

'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'var result = shape switch
'{
'	Circle c => $"Circle with radius {c.Radius}",
'	Rectangle r => $"Rectangle with dimensions {r.Length}x{r.Width}",
'	_ => "Unknown shape"
'};

Dans ce cas, la valeur d'entrée initiale, la variable shape est déconstruite en ses composants (Cercle ou Rectangle), et le message approprié est généré en fonction du type et des valeurs.

4. Expression Switch vs. Instruction Switch

Bien que l'expression switch partage des similitudes avec le modèle sémantique traditionnel de type switch, elle offre plusieurs avantages. L'expression du mot-clé switch est plus concise, éliminant le besoin d'instructions break-case et réduisant le code modèle. Elle permet également l'affectation de valeurs directement au sein de l'expression, rendant le code plus expressif.

Une autre caractéristique notable est la capacité d'utiliser des expressions de l'expression switch dans une expression lambda ou dans le cadre d'un membre avec corps d'expression dans des méthodes ou des propriétés, contribuant à un style de programmation plus fonctionnel.

De plus, l'expression switch encourage l'utilisation de la correspondance de motif constant, offrant une manière plus naturelle et puissante de gérer différents cas.

5. Considérations de Performance et Limitations

Bien que l'expression switch apporte de nombreux avantages, il est crucial d'être conscient des considérations de performance. Dans certains scénarios, l'instruction switch peut être plus performante, surtout lorsqu'il s'agit d'un grand nombre de cas. Les développeurs doivent évaluer les exigences spécifiques de leur application et choisir la construction appropriée en conséquence.

Un autre point à noter est que l'expression switch ne peut pas remplacer entièrement l'instruction switch. Il existe des cas où l'instruction switch, avec son comportement de passage, pourrait être le choix préféré.

De plus, l'expression switch n'est disponible que dans C# 8.0 et les versions ultérieures, donc les projets ciblant des versions antérieures n'auront pas accès à cette fonctionnalité.

La fonctionnalité remarquable d'IronPDF est sa fonction de conversion de HTML en PDF, préservant tous les agencements et styles. Elle permet la génération de PDF à partir de contenu web, idéale pour les rapports, factures et documentation. Les fichiers HTML, les URLs et les chaînes HTML peuvent être convertis en PDFs sans effort.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

6. Application en Conditions Réelles avec IronPDF

L'application de l'expression switch en C# est particulièrement impactante dans les scénarios du monde réel, surtout lorsqu'il s'agit de gérer plusieurs conditions ou énumérations, comme illustré dans un cas d'utilisation d'IronPDF. Explorons sa praticité dans un système de classification de documents.

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        // Simulate HTML content for the PDF document
        string htmlContent = GetHtmlContent();
        
        // Creating IronPDF Document
        var pdfDocument = new ChromePdfRenderer();
        
        // Converting HTML to PDF
        var pdf = pdfDocument.RenderHtmlAsPdf(htmlContent);
        
        // Classifying the document based on the page count
        string classification = pdf switch
        {
            { PageCount: 1 } => "Single Page Document",
            { PageCount: >= 2 and <= 10 } => "Small Document",
            { PageCount: > 10 } => "Large Document",
            _ => "Unknown Classification"
        };
        
        // Save the PDF to a file
        pdf.SaveAs("document_output.pdf");
        
        // Displaying the classification result
        Console.WriteLine($"PDF created successfully. Document Classification: {classification}");
    }

    static string GetHtmlContent()
    {
        // In a real-world scenario, you would obtain the HTML content from an actual source.
        // For the sake of this example, we'll create a simple HTML string.
        string htmlContent = "<html><body><h1>Hello IronPDF!</h1><p>This is a sample HTML content.</p></body></html>";
        return htmlContent;
    }
}

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        // Simulate HTML content for the PDF document
        string htmlContent = GetHtmlContent();
        
        // Creating IronPDF Document
        var pdfDocument = new ChromePdfRenderer();
        
        // Converting HTML to PDF
        var pdf = pdfDocument.RenderHtmlAsPdf(htmlContent);
        
        // Classifying the document based on the page count
        string classification = pdf switch
        {
            { PageCount: 1 } => "Single Page Document",
            { PageCount: >= 2 and <= 10 } => "Small Document",
            { PageCount: > 10 } => "Large Document",
            _ => "Unknown Classification"
        };
        
        // Save the PDF to a file
        pdf.SaveAs("document_output.pdf");
        
        // Displaying the classification result
        Console.WriteLine($"PDF created successfully. Document Classification: {classification}");
    }

    static string GetHtmlContent()
    {
        // In a real-world scenario, you would obtain the HTML content from an actual source.
        // For the sake of this example, we'll create a simple HTML string.
        string htmlContent = "<html><body><h1>Hello IronPDF!</h1><p>This is a sample HTML content.</p></body></html>";
        return htmlContent;
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main()
        ' Simulate HTML content for the PDF document
        Dim htmlContent As String = GetHtmlContent()
        
        ' Creating IronPDF Document
        Dim pdfDocument = New ChromePdfRenderer()
        
        ' Converting HTML to PDF
        Dim pdf = pdfDocument.RenderHtmlAsPdf(htmlContent)
        
        ' Classifying the document based on the page count
        Dim classification As String = If(pdf.PageCount = 1, "Single Page Document", 
                                          If(pdf.PageCount >= 2 AndAlso pdf.PageCount <= 10, "Small Document", 
                                             If(pdf.PageCount > 10, "Large Document", "Unknown Classification")))
        
        ' Save the PDF to a file
        pdf.SaveAs("document_output.pdf")
        
        ' Displaying the classification result
        Console.WriteLine($"PDF created successfully. Document Classification: {classification}")
    End Sub

    Function GetHtmlContent() As String
        ' In a real-world scenario, you would obtain the HTML content from an actual source.
        ' For the sake of this example, we'll create a simple HTML string.
        Dim htmlContent As String = "<html><body><h1>Hello IronPDF!</h1><p>This is a sample HTML content.</p></body></html>"
        Return htmlContent
    End Function
End Module

Imports IronPdf
Imports System

Module Program
    Sub Main()
        ' Simulate HTML content for the PDF document
        Dim htmlContent As String = GetHtmlContent()
        
        ' Creating IronPDF Document
        Dim pdfDocument = New ChromePdfRenderer()
        
        ' Converting HTML to PDF
        Dim pdf = pdfDocument.RenderHtmlAsPdf(htmlContent)
        
        ' Classifying the document based on the page count
        Dim classification As String = If(pdf.PageCount = 1, "Single Page Document", 
                                          If(pdf.PageCount >= 2 AndAlso pdf.PageCount <= 10, "Small Document", 
                                             If(pdf.PageCount > 10, "Large Document", "Unknown Classification")))
        
        ' Save the PDF to a file
        pdf.SaveAs("document_output.pdf")
        
        ' Displaying the classification result
        Console.WriteLine($"PDF created successfully. Document Classification: {classification}")
    End Sub

    Function GetHtmlContent() As String
        ' In a real-world scenario, you would obtain the HTML content from an actual source.
        ' For the sake of this example, we'll create a simple HTML string.
        Dim htmlContent As String = "<html><body><h1>Hello IronPDF!</h1><p>This is a sample HTML content.</p></body></html>"
        Return htmlContent
    End Function
End Module

Dans cet extrait de code C#, le ChromePdfRenderer d'IronPDF est utilisé pour convertir le contenu HTML simulé en un document PDF. Le PDF résultant est ensuite classé en fonction de son nombre de pages à l'aide d'une expression switch.

L'expression switch utilise un motif récursif pour catégoriser le document en différents types, tels que 'Document à une seule page', 'Petit document' ou 'Grand document', selon des plages de nombre de pages spécifiques. Le document classé est ensuite enregistré dans un fichier nommé "document_output.pdf", et un message de la console communique la création réussie du PDF avec son résultat de classification.

Cette approche concise et dynamique montre la polyvalence de l'expression switch dans la gestion efficace de divers scénarios, offrant un moyen simplifié de catégoriser les documents en fonction de leurs propriétés.

6.1. Console de Sortie

7. Conclusion

L'expression switch en C#, introduite dans C# 8.0 en tant qu'évolution essentielle du langage, a émergé comme un outil convaincant pour les développeurs afin de rationaliser la logique conditionnelle et d'améliorer l'expressivité du code.

Cette exploration approfondie a examiné sa syntaxe, ses applications et ses avantages, montrant sa polyvalence à travers des exemples employant divers modèles positionnels et des mots-clés tels que "switch" et "case". De sa syntaxe intuitive et son utilisation de base à sa déclaration avancée de modèle et ses capacités de déconstruction, l'expression switch s'est avérée inestimable pour créer un code propre et lisible.

La comparaison avec l'instruction switch traditionnelle met en lumière sa concision et son soutien aux constructions expressives, y compris les expressions lambda et les membres avec corps d'expression. La capacité d'intégrer de manière transparente avec des bibliothèques externes et de contribuer à la génération simplifiée de PDF souligne encore davantage le rôle de l'expression switch dans l'avancement des pratiques de développement modernes en C#.

Alors que C# continue d'évoluer, l'expression switch se tient comme un témoignage de l'engagement du langage à doter les développeurs d'outils efficaces et expressifs pour une résolution de problèmes efficace.