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

C# évolue en permanence et intègre des fonctionnalités qui améliorent l'expressivité du langage et l'expérience globale du développeur. Parmi ces caractéristiques, l'expression "switch" est particulièrement remarquable, car elle constitue un outil puissant et succinct pour gérer plusieurs conditions au sein d'une seule expression.

Cette exploration complète se penche sur les subtilités de l'expression switch en C#, en fournissant des exemples qui mettent en évidence sa syntaxe, ses applications et ses avantages.

De la recherche de motifs et des valeurs constantes aux modèles de type et à l'utilisation de mots-clés tels que "switch" et "case", nous naviguons à travers les divers éléments de cette caractéristique du langage. La discussion porte sur différents modèles, tels que les modèles constants, les modèles relationnels et les modèles de type, et élucide leur rôle dans le contexte de l'expression du commutateur.

En outre, nous examinons l'incorporation des expressions de commutation dans des scénarios réels, en démontrant leur utilité et en clarifiant leur syntaxe et leur mise en œuvre. Pour en savoir plus sur les expressions de commutation, consultez le site suivantDocumentation Microsoft sur les expressions de commutation en C#.

Dans cet article, nous allons passer en revue les exemples d'expressions de commutation et tester leur cas d'utilisation à l'aide de la fonctionIronPDF C# PDF Library (Bibliothèque PDF C#).

1. Introduction à l'expression des commutateurs

L'expression switch, introduite dans C# 8.0, représente un changement de paradigme dans la manière dont les développeurs gèrent la logique conditionnelle. Traditionnellement, l'instruction switch était le choix idéal pour effectuer des branchements en fonction de différentes valeurs, mais elle présentait des limites en termes de verbosité et de flexibilité lors de l'utilisation des mots-clé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 elle 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 et plus lisible, avec une réduction du nombre d'éléments superflus.

2. Syntaxe et utilisation de base

La syntaxe de l'expression switch C# est intuitive, ce qui la rend facile à adopter pour les développeurs familiarisés 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" 
};

IRON VB CONVERTER ERROR developers@ironsoftware.com

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 résultat. Le trait de soulignement(_) représente le cas optionnel par défaut, similaire au mot-clé default dans une instruction de commutation traditionnelle.

L'expression switch prend en charge un large éventail de modèles, notamment les modèles constants, les modèles de type, les modèles relationnels et bien d'autres encore, ce qui en fait un outil polyvalent pour gérer des scénarios complexes. Elle peut s'avérer particulièrement utile dans le cas des énumérations, en évitant d'avoir recours à des déclarations case répétitives.

3. Modèles avancés et déconstruction

L'une des forces 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 à partir d'objets, de tableaux et de modèles de manière concise. Prenons l'exemple suivant d'une expression de commutation :

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"
'};

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

4. Expression de commutation ou déclaration de commutation

Bien que l'expression "switch" présente 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 standard. Il permet également d'assigner des valeurs directement dans l'expression, ce qui rend le code plus expressif.

Une autre caractéristique notable est la possibilité d'utiliser des expressions de l'expression switch dans une expression lambda ou en tant que membre d'une expression dans des méthodes ou des propriétés, ce qui contribue à un style de programmation plus fonctionnel.

En outre, l'expression "switch" encourage l'utilisation de la recherche de motifs constants, ce qui constitue un moyen plus naturel et plus puissant de traiter les différents cas.

5. Considérations sur les performances et les limites

Si l'expression "switch" présente de nombreux avantages, il est essentiel de tenir compte des aspects liés à la performance. Dans certains cas, l'instruction switch peut être plus performante, notamment 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.

Il convient également de noter que l'expression "switch" ne peut pas remplacer entièrement l'instruction "switch". Dans certains cas, l'instruction switch, avec son comportement en cascade, peut être le meilleur choix.

En outre, l'expression "switch" n'est disponible qu'à partir de la version 8.0 de C#, de sorte que les projets ciblant des versions antérieures n'auront pas accès à cette fonctionnalité.

La caractéristique principale d'IronPDF est sonConversion de HTML en PDF en préservant toutes les mises en page et tous les styles. Il permet de générer des PDF à partir de contenus web, ce qui est idéal pour les rapports, les factures et la documentation. Les fichiers HTML, les URL et les chaînes HTML peuvent être convertis en PDF 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

6. Applications concrètes avec IronPDF

L'application de l'expression switch en C# a un impact considérable dans les scénarios réels, notamment lorsqu'il s'agit de gérer plusieurs conditions ou énumérations, comme l'illustre un cas d'utilisation d'IronPDF. Explorons son utilité dans un système de classification des documents.

using IronPdf;
using System;
class Program
{
    static void Main()
    {
        // Simulating 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()
    {
        // Simulating 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
Friend Class Program
	Shared Sub Main()
		' Simulating 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
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		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}")
	End Sub
	Private Shared 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 Class

Dans cet extrait de code C#, le ChromePdfRenderer d'IronPDF est utilisé pour convertir un contenu HTML simulé en un document PDF. Le PDF résultant est ensuite soumis à une classification basée sur le nombre de pages à l'aide d'une expression de commutation.

L'expression de commutation utilise un modèle récursif pour classer le document en différents types, tels que "Document d'une seule page", "Petit document" ou "Grand document", en fonction de plages spécifiques de nombre de pages. Le document classifié est ensuite enregistré dans un fichier nommé "document_output.pdf", et un message de la console communique la création réussie du PDF ainsi que le résultat de la classification.

Cette approche concise et dynamique met en évidence la polyvalence de l'expression switch dans la gestion efficace de différents scénarios, en fournissant un moyen rationalisé 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 en C# 8.0 comme une évolution essentielle du langage, s'est imposée comme un outil incontournable permettant aux développeurs de rationaliser la logique conditionnelle et d'améliorer l'expressivité du code.

Cette exploration complète a porté sur sa syntaxe, ses applications et ses avantages, et a mis en évidence sa polyvalence à travers des exemples employant divers modèles de position et des mots-clés tels que "switch" et "case" Depuis sa syntaxe intuitive et son utilisation de base jusqu'au modèle de déclaration avancé et aux 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 évidence sa concision et sa prise en charge des constructions expressives, y compris les expressions lambda et les membres à corps d'expression. La capacité à s'intégrer de manière transparente avec des bibliothèques externes et à contribuer à la rationalisation de la génération de PDF souligne encore davantage le rôle de l'expression switch dans l'avancement des pratiques de développement C# modernes.

Alors que le langage C# continue d'évoluer, l'expression "switch" témoigne de l'engagement du langage à fournir aux développeurs des outils efficaces et expressifs pour résoudre efficacement les problèmes.