Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Déclaration de Cas C#
.NET AIDE

Déclaration de cas C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

La déclaration switch en C# offre une alternative plus simplifiée et lisible aux multiples blocs if-else. C'est bénéfique lorsque vous avez une variable qui peut prendre une des plusieurs valeurs distinctes, et vous devez exécuter un code différent basé sur la valeur. La déclaration switch évalue une expression et exécute un code basé sur la valeur correspondante, en faisant une partie intégrante de la prise de décision dans votre code.

Bien que les structures if-else soient utiles pour des conditions simples ou des vérifications, les déclarations case switch excellent lorsqu'il s'agit de vérifications de conditions plus complexes, en particulier celles basées sur une seule variable ou une expression de correspondance de modèle. Elles fournissent une syntaxe plus propre et plus compréhensible par rapport aux déclarations if, ce qui est essentiel tant pour l'écriture que pour la maintenance du code.

Les bases de la déclaration Switch

Qu'est-ce qu'une déclaration Switch ?

Une déclaration switch en C# est une structure de contrôle utilisée pour sélectionner un des nombreux chemins de code à exécuter. La sélection est basée sur la valeur ou une expression. C'est une alternative efficace à l'utilisation de multiples conditions if-else, en particulier lorsque vous traitez avec une variable qui peut avoir plusieurs valeurs distinctes.

Syntaxe

La syntaxe de base d'une déclaration switch est simple:

// Switch statement
switch (variable)
{
    case value1:
        // Code to execute if variable equals value1
        break;
    case value2:
        // Code to execute if variable equals value2
        break;
    // More cases as needed
    default:
        // Code to execute if variable doesn't match any case
        break;
}
// Switch statement
switch (variable)
{
    case value1:
        // Code to execute if variable equals value1
        break;
    case value2:
        // Code to execute if variable equals value2
        break;
    // More cases as needed
    default:
        // Code to execute if variable doesn't match any case
        break;
}
' Switch statement
Select Case variable
	Case value1
		' Code to execute if variable equals value1
	Case value2
		' Code to execute if variable equals value2
	' More cases as needed
	Case Else
		' Code to execute if variable doesn't match any case
End Select
$vbLabelText   $csharpLabel
  • switch (variable): Cela spécifie la variable ou l'expression à évaluer.
  • case valeur1: Ce sont les différentes valeurs ou conditions contre lesquelles vous vérifiez la variable.
  • break: Ce mot clé est utilisé pour sortir du bloc switch une fois qu'un case correspondant est exécuté.
  • instruction default: Ce bloc s'exécute si aucun des cases spécifiés ne correspond à la variable.

Comprendre l'instruction Break

L'instruction break dans le switch est cruciale. Elle empêche le comportement de "fall through", où l'exécution passe au case suivant même si la condition correspondante est déjà respectée. Chaque bloc case se termine généralement par une instruction break pour garantir que seul le code sous le case correspondant est exécuté.

Comparer la déclaration Switch et les déclarations If-Else

Alors que la structure de la déclaration if-else implique de vérifier une condition et d'exécuter un bloc de code si la condition est vraie, les déclarations switch comparent une seule variable ou expression à plusieurs valeurs potentielles. Ceci rend la déclaration switch plus concise et plus facile à lire lorsque vous avez beaucoup de conditions ou de modèles à vérifier.

Exemple : Utiliser une déclaration Switch

int number = 3;
switch (number)
{
    case 1:
        Console.WriteLine("One");
        break;
    case 2:
        Console.WriteLine("Two");
        break;
    case 3:
        Console.WriteLine("Three");
        break;
    default:
        Console.WriteLine("Other Number"); // Print to console
        break;
}
int number = 3;
switch (number)
{
    case 1:
        Console.WriteLine("One");
        break;
    case 2:
        Console.WriteLine("Two");
        break;
    case 3:
        Console.WriteLine("Three");
        break;
    default:
        Console.WriteLine("Other Number"); // Print to console
        break;
}
Dim number As Integer = 3
Select Case number
	Case 1
		Console.WriteLine("One")
	Case 2
		Console.WriteLine("Two")
	Case 3
		Console.WriteLine("Three")
	Case Else
		Console.WriteLine("Other Number") ' Print to console
End Select
$vbLabelText   $csharpLabel

Dans cet exemple, le programme imprimera "Trois" en sortie puisque le nombre correspond au case 3.

Le rôle du case Default

Comprendre le Default dans un bloc Switch

Dans une déclaration switch, le case default joue un rôle crucial. Il sert d'option de secours qui est exécutée quand aucun des labels de case spécifiés ne correspond à la valeur de l'expression switch. Bien qu'il soit optionnel, inclure un case default est une bonne pratique pour gérer les valeurs inattendues ou inconnues.

Comment et quand utiliser l'instruction Default

Le case default est utilisé lorsque vous souhaitez exécuter un bloc de code si aucun des cas spécifiques ne correspond. Il garantit que la déclaration switch a toujours un comportement défini, quelle que soit l'entrée. Le case default est déclaré en utilisant le mot clé default, suivi d'un deux-points.

default:
    // Code to execute if no case matches
    break;
default:
    // Code to execute if no case matches
    break;
Case Else
	' Code to execute if no case matches
	break
$vbLabelText   $csharpLabel

Le case default peut être placé n'importe où dans le bloc switch, mais il est généralement placé à la fin pour la lisibilité.

Exemple : Déclaration Switch avec case Default

Considérons un scénario où vous évaluez un jour de la semaine :

int day = 5;
string dayName;
switch (day)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
        break;
}
Console.WriteLine(dayName);
int day = 5;
string dayName;
switch (day)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
        break;
}
Console.WriteLine(dayName);
Dim day As Integer = 5
Dim dayName As String
Select Case day
	Case 1
		dayName = "Monday"
	Case 2
		dayName = "Tuesday"
	Case 3
		dayName = "Wednesday"
	Case 4
		dayName = "Thursday"
	Case 5
		dayName = "Friday"
	Case 6
		dayName = "Saturday"
	Case 7
		dayName = "Sunday"
	Case Else
		dayName = "Invalid day"
End Select
Console.WriteLine(dayName)
$vbLabelText   $csharpLabel

Dans cet exemple, si day a une valeur autre que 1 à 7, le case default est exécuté, réglant dayName sur "Jour invalide".

Meilleures pratiques pour le case Default

  • Incluez toujours un Default: Même si vous croyez avoir couvert tous les cas possibles, incluez un case default pour gérer les valeurs imprévues.
  • Actions significatives: Utilisez le case default pour effectuer des actions significatives, comme enregistrer une erreur, définir une valeur par défaut ou notifier l'utilisateur d'une valeur inconnue.

Fonctionnalités avancées du Switch

Introduction aux expressions Switch en C#

Avec l'évolution de C#, les expressions switch ont été introduites comme une manière plus concise et expressive de gérer plusieurs branches conditionnelles. Contrairement aux déclarations switch traditionnelles, les expressions switch retournent une valeur et sont plus rationalisées, en faisant un outil puissant dans la programmation moderne C#.

Syntaxe of Switch Expressions

La syntaxe d'une expression switch en C# est une forme plus compacte de la déclaration case switch. Voici une structure de base :

var result = variable switch
{
    value1 => result1,
    value2 => result2,
    _ => defaultResult
};
var result = variable switch
{
    value1 => result1,
    value2 => result2,
    _ => defaultResult
};
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'var result = variable switch
'{
'	value1 => result1,
'	value2 => result2,
'	_ => defaultResult
'};
$vbLabelText   $csharpLabel

Le symbole underscore (_) représente le case default dans les expressions switch, fonctionnant de manière similaire au bloc default dans les déclarations switch traditionnelles.

Exemple : Utilisation d'une expression Switch

Considérez un scénario où vous devez catégoriser une lecture de température :

int temperature = 25;
string weatherDescription = temperature switch
{
    <= 0 => "Freezing",
    < 20 => "Cold",
    < 30 => "Mild",
    _ => "Hot"
};
Console.WriteLine(weatherDescription);
int temperature = 25;
string weatherDescription = temperature switch
{
    <= 0 => "Freezing",
    < 20 => "Cold",
    < 30 => "Mild",
    _ => "Hot"
};
Console.WriteLine(weatherDescription);
Dim temperature As Integer = 25
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'string weatherDescription = temperature switch
'{
'	<= 0 => "Freezing",
'	< 20 => "Cold",
'	< 30 => "Mild",
'	_ => "Hot"
'};
Console.WriteLine(weatherDescription)
$vbLabelText   $csharpLabel

Dans cet exemple, l'expression switch catégorise succinctement la température, le case default (_) couvrant tout scénario non répondu par les autres cas.

Correspondance de modèles avec les expressions Switch

Les expressions switch en C# permettent la correspondance de modèles, ce qui les rend encore plus polyvalentes. Vous pouvez faire correspondre des types, des valeurs ou même des modèles :

object obj = // some object;
string description = obj switch
{
    int i => $"Integer: {i}",
    string s => $"String: {s}",
    _ => "Unknown type"
};
object obj = // some object;
string description = obj switch
{
    int i => $"Integer: {i}",
    string s => $"String: {s}",
    _ => "Unknown type"
};
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'object obj = string description = obj switch
'{
'	int i => $"Integer: {i}",
'	string s => $"String: {s}",
'	_ => "Unknown type"
'};
$vbLabelText   $csharpLabel

Déclaration Switch C# vs Expression Switch

  • Déclaration Switch C#: Traditionnellement utilisée pour exécuter différents blocs de code en fonction de la valeur d'une variable. Elle nécessite une instruction break pour chaque case.
  • Expression Switch: Introduite dans C# 8.0, cela procure une syntaxe plus concise et est typiquement utilisée lorsqu'une valeur doit être retournée en fonction d'une condition.

Intégrer des déclarations Switch avec IronPDF en C#

Déclaration Case C# (Comment ça fonctionne pour les développeurs) : Figure 1 - IronPDF

Explorer les fonctionnalités d'IronPDF est une bibliothèque PDF .NET pour créer, éditer, et travailler avec des documents PDF. Lorsqu'elle est combinée avec des déclarations ou expressions switch C#, elle devient un outil puissant pour gérer différentes opérations liées au PDF basées sur des conditions spécifiques. Cette intégration est particulièrement utile pour les tâches nécessitant une prise de décision basée sur le contenu ou les métadonnées du PDF.

La fonctionnalité clé d'IronPDF est de convertir HTML en PDF avec les mises en page et styles, tout en conservant les mises en page et les styles intacts. C'est idéal pour créer des PDF à partir de contenu web, y compris les rapports, les factures et la documentation. Les fichiers HTML, les URL et les chaînes HTML sont tous convertibles en fichiers 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");
    }
}
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
$vbLabelText   $csharpLabel

Exemple : Filigrane conditionnel avec IronPDF et déclarations Switch

Considérons un scénario où vous avez un document PDF, et vous souhaitez appliquer différents filigranes selon le nombre de pages en fonction du nombre de pages dans le document. Voici comment vous pouvez réaliser cela en utilisant IronPDF en combinaison avec une déclaration switch C# :

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        IronPdf.License.LicenseKey = "Your-License-Code";
        PdfDocument pdf = PdfDocument.FromFile("sample.pdf");
        // Define different watermark HTML for each case
        string watermarkHtmlOnePage = "<div style='color:red;'>One Page Document</div>";
        string watermarkHtmlTwoPage = "<div style='color:blue;'>Two Page Document</div>";
        switch (pdf.PageCount)
        {
            case 1:
                // Apply watermark for one-page document
                pdf.ApplyWatermark(watermarkHtmlOnePage);
                break;
            case 2:
                // Apply watermark for two-page documents
                pdf.ApplyWatermark(watermarkHtmlTwoPage);
                break;
            default:
                // Apply a default watermark for other cases
                pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>");
                break;
        }
        // Save the watermarked PDF
        pdf.SaveAs("watermarked.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        IronPdf.License.LicenseKey = "Your-License-Code";
        PdfDocument pdf = PdfDocument.FromFile("sample.pdf");
        // Define different watermark HTML for each case
        string watermarkHtmlOnePage = "<div style='color:red;'>One Page Document</div>";
        string watermarkHtmlTwoPage = "<div style='color:blue;'>Two Page Document</div>";
        switch (pdf.PageCount)
        {
            case 1:
                // Apply watermark for one-page document
                pdf.ApplyWatermark(watermarkHtmlOnePage);
                break;
            case 2:
                // Apply watermark for two-page documents
                pdf.ApplyWatermark(watermarkHtmlTwoPage);
                break;
            default:
                // Apply a default watermark for other cases
                pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>");
                break;
        }
        // Save the watermarked PDF
        pdf.SaveAs("watermarked.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		IronPdf.License.LicenseKey = "Your-License-Code"
		Dim pdf As PdfDocument = PdfDocument.FromFile("sample.pdf")
		' Define different watermark HTML for each case
		Dim watermarkHtmlOnePage As String = "<div style='color:red;'>One Page Document</div>"
		Dim watermarkHtmlTwoPage As String = "<div style='color:blue;'>Two Page Document</div>"
		Select Case pdf.PageCount
			Case 1
				' Apply watermark for one-page document
				pdf.ApplyWatermark(watermarkHtmlOnePage)
			Case 2
				' Apply watermark for two-page documents
				pdf.ApplyWatermark(watermarkHtmlTwoPage)
			Case Else
				' Apply a default watermark for other cases
				pdf.ApplyWatermark("<div style='color:green;'>Multiple Page Document</div>")
		End Select
		' Save the watermarked PDF
		pdf.SaveAs("watermarked.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Voici le fichier PDF de sortie d'une page :

Déclaration Case C# (Comment ça fonctionne pour les développeurs) : Figure 2 - Output

Conclusion

Dans ce tutoriel, nous avons exploré la déclaration switch case en C#, une forme fondamentale de prise de décision en programmation. Nous avons commencé par comprendre sa structure de base et l'avons comparée avec les déclarations if-else traditionnelles, mettant en avant ses avantages en termes de lisibilité et de simplicité pour gérer de multiples conditions.

Nous avons créé des cases switch simples, géré divers scénarios avec le case default, et exploré des fonctionnalités avancées comme les expressions switch. L'application réelle des déclarations switch a été démontrée à travers un exemple intégrant IronPDF pour le traitement dynamique de PDF, montrant comment les déclarations switch peuvent être un outil précieux dans la boîte à outils d'un programmeur.

IronPDF offre un essai gratuit pour explorer les fonctionnalités, vous permettant d'explorer ses caractéristiques et fonctionnalités. Pour une utilisation continue et un accès à sa suite complète d'outils, les licences IronPDF commencent à partir d'un modèle de tarification compétitif, fournissant une solution complète pour tous vos besoins de traitement PDF en C#.

Questions Fréquemment Posées

Comment puis-je utiliser une instruction switch pour gérer le traitement de PDF en C# ?

Vous pouvez utiliser une instruction switch pour gérer le traitement de PDF en exécutant différentes opérations PDF en fonction des conditions, telles que le nombre de pages ou le type de document, en utilisant une bibliothèque comme IronPDF.

Quelle est la différence entre une instruction switch et une expression switch en C# ?

Une instruction switch offre un moyen structuré de gérer plusieurs conditions avec des instructions break pour éviter le « fall-through », tandis qu'une expression switch est plus concise, renvoie une valeur, et élimine le besoin d'instructions break.

Pourquoi le cas par défaut est-il important dans les instructions switch en C# ?

Le cas par défaut est crucial car il assure que les valeurs inattendues sont gérées de manière élégante, en empêchant les erreurs en fournissant une action de secours quand aucun cas ne correspond à l'expression.

Comment les expressions switch améliorent-elles la lisibilité du code en C# ?

Les expressions switch améliorent la lisibilité du code en offrant une syntaxe concise pour le branchement conditionnel, permettant aux développeurs d'exprimer la logique de manière plus compacte, ce qui rend le code plus facile à comprendre et à maintenir.

Les instructions switch peuvent-elles être utilisées pour la gestion des erreurs dans les applications C# ?

Oui, les instructions switch peuvent être utilisées pour la gestion des erreurs en dirigeant le programme vers des routines spécifiques de gestion d'erreurs basées sur des codes d'erreurs ou des conditions, améliorant ainsi la robustesse des applications C#.

Quel est un exemple pratique d'utilisation d'une instruction switch avec IronPDF ?

Un exemple pratique est d'utiliser une instruction switch pour appliquer différents filigranes à un document PDF en fonction de son nombre de pages ou d'autres critères, en utilisant IronPDF pour les tâches de manipulation de PDF.

Comment IronPDF facilite-t-il les opérations PDF basées sur des switch ?

IronPDF facilite les opérations PDF basées sur des switch en fournissant un ensemble robuste d'outils et de méthodes qui peuvent être déclenchés conditionnellement à l'aide d'instructions switch pour des tâches telles que la conversion, l'édition et le rendu de PDF.

Quelles sont les utilisations courantes des instructions switch dans le traitement de PDF ?

Les cas d'utilisation courants incluent l'application de différentes règles de traitement basées sur les métadonnées du document, telles que l'application de formatages ou de conversions spécifiques en fonction du type ou du contenu du document.

Comment IronPDF peut-il aider à créer du code lisible et maintenable avec des instructions switch ?

IronPDF aide en offrant des méthodes complètes de manipulation de PDF qui peuvent être organisées à l'aide d'instructions switch, aboutissant à un code à la fois lisible et maintenable grâce à sa logique structurée.

Quels avantages les instructions switch offrent-elles par rapport aux blocs if-else dans la prise de décision ?

Les instructions switch offrent une structure plus organisée et moins sujette aux erreurs pour traiter de multiples conditions discrètes, améliorant la clarté du code et réduisant la probabilité d'erreurs par rapport aux longues chaînes if-else.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit