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

L'instruction switch en C# offre une alternative plus rationalisée et lisible aux multiples expressions if-else. Elle est utile lorsque vous avez une variable qui peut prendre une ou plusieurs valeurs distinctes et que vous devez exécuter un code différent en fonction de la valeur. Cette instruction case évalue une expression et exécute le code principal static void en fonction de la valeur correspondante, ce qui en fait une partie intégrante de la prise de décision dans votre code.

Si les structures if-else sont idéales pour les conditions ou les contrôles simples, les instructions switch case brillent lorsqu'il s'agit de contrôles de conditions plus complexes, en particulier ceux basés sur une variable unique ou une expression de correspondance de motifs. Ils offrent une syntaxe plus propre et plus compréhensible que l'instruction if, ce qui est crucial pour l'écriture et la maintenance du même code.

Principes de base de la déclaration de changement de fournisseur

Qu'est-ce qu'une déclaration de changement de fournisseur ?

Une instruction switch en C# est une structure de contrôle utilisée pour sélectionner l'un des nombreux chemins de code à exécuter. La sélection est basée sur la valeur ou sur une expression avec l'un des types de données. Il s'agit d'une alternative efficace à l'utilisation de plusieurs conditions if-else, en particulier lorsqu'il s'agit d'une variable pouvant avoir plusieurs valeurs distinctes.

Syntaxe

La syntaxe de base d'une instruction de commutation 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 or fall through behavior
        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 or fall through behavior
        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 or fall through behavior
End Select

• switch (variable) : C'est ici que vous spécifiez la variable ou l'expression à évaluer comme indiqué dans le programme ci-dessus.
• case value1 : Ce sont les différentes valeurs ou conditions que vous vérifiez par rapport à la variable.
• break : Ce mot-clé est utilisé pour quitter le bloc switch une fois qu'un cas correspondant a été exécuté.
• default statement : Ce bloc goto optionnel s'exécute si aucun des cas spécifiés ne correspond à la variable.

Comprendre la déclaration de rupture

La déclaration de rupture dans le commutateur est cruciale. Il empêche le comportement "fall through", où l'exécution passe au cas suivant même si la condition correspondante est déjà remplie. Chaque bloc de cas se termine généralement par une instruction break qui garantit que seul le code du cas correspondant est exécuté.

Comparaison entre l'instruction Switch et l'instruction If-Else

Alors que la structure de l'instruction if-else implique la vérification d'une condition et l'exécution d'un bloc de code si la condition est vraie, les instructions switch comparent une seule variable ou expression à plusieurs valeurs potentielles. Cela rend l'instruction switch plus concise et plus facile à lire lorsque vous avez de nombreuses conditions ou modèles de cas à vérifier.

Exemple : Utilisation d'une instruction 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

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

Le rôle du cas par défaut

Comprendre la valeur par défaut d'un bloc de commutateurs

Dans une déclaration de commutation, le cas par défaut joue un rôle crucial. Il s'agit d'une option fourre-tout qui est exécutée lorsqu'aucune des étiquettes de cas spécifiées ne correspond à la valeur de l'expression du commutateur. Bien qu'elle soit facultative, l'inclusion d'un cas par défaut est une bonne pratique, en particulier pour gérer les valeurs inattendues ou inconnues.

Comment et quand utiliser la déclaration par défaut

Le cas par défaut est utilisé lorsque vous souhaitez exécuter un bloc de code si aucun des cas spécifiques ne correspond. Elle garantit que l'instruction de commutation a toujours un comportement défini, quelle que soit l'entrée. Le cas par défaut est déclaré à l'aide du 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

Le cas par défaut peut être placé n'importe où dans le bloc de commutation, mais il est généralement placé à la fin pour des raisons de lisibilité.

Exemple : Déclaration de changement avec cas par défaut

Imaginez un scénario dans lequel 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)

Dans cet exemple, si day a une valeur différente de 1 à 7, le cas par défaut est exécuté, définissant dayName sur "Jour invalide".

Bonnes pratiques pour le cas par défaut

Toujours inclure une valeur par défaut : Même si vous pensez avoir couvert tous les cas possibles, incluez un cas par défaut pour gérer les valeurs imprévues.

Actions Significatives : Utilisez le cas par défaut pour effectuer des actions significatives, telles que l'enregistrement d'une erreur, la définition d'une valeur par défaut ou la notification à l'utilisateur d'une valeur inconnue.

Fonctionnalités avancées du commutateur

Introduction aux expressions de commutation en C# ;

Avec l'évolution de C#, les expressions de commutation ont été introduites comme un moyen plus concis et plus expressif de gérer plusieurs branches conditionnelles. Contrairement aux instructions de commutation traditionnelles, les expressions de commutation renvoient une valeur et sont plus rationnelles, ce qui en fait un outil puissant dans la programmation C# moderne.

Syntaxe des expressions de commutation

La syntaxe d'une expression switch en C# est une forme plus compacte de l'instruction switch case. 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
'};

Le symbole souligné (_) représente le cas par défaut dans les expressions switch, fonctionnant de manière similaire au bloc par défaut dans les instructions switch traditionnelles.

Exemple : Utilisation d'une expression de commutation

Prenons l'exemple d'un scénario dans lequel vous devez classer un relevé de température par catégorie :

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)

Dans cet exemple, l'expression switch catégorise succinctement la température, avec le cas par défaut (_) couvrant tout scénario non couvert par les autres cas.

Correspondance de motifs avec les expressions de commutation

En C#, les expressions de commutation permettent la recherche de motifs, ce qui les rend encore plus polyvalentes. Vous pouvez faire correspondre des types, des valeurs ou même des motifs :

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

C&num ; Déclaration de commutation vs. expression de commutation

Instruction Switch en C# : Traditionnellement utilisée pour exécuter différents blocs de code en fonction de la valeur d'une variable. Elle nécessite une déclaration de rupture pour chaque cas.

Expression switch : Introduite dans C# 8.0, elle offre une syntaxe plus concise et est généralement utilisée lorsqu'une valeur doit être renvoyée en fonction d'une condition.

Intégrer les Switch Statements avec IronPDF dans C&num ;

Explorez les fonctionnalités d'IronPDF est une bibliothèque PDF .NET pour créer, éditer et travailler avec des documents PDF. Lorsqu'il est associé à des instructions ou à des expressions de commutation C#, il devient un outil puissant pour gérer diverses opérations liées au PDF en fonction de conditions spécifiques. Cette intégration est particulièrement utile pour les tâches qui nécessitent une prise de décision basée sur le contenu ou les métadonnées des PDF.

La fonctionnalité principale de IronPDF est la conversion de HTML en PDF avec des mises en page et des styles, tout en préservant les mises en page et les styles intacts. Ceci est idéal pour créer des PDF à partir de contenu web, y compris des rapports, des factures et de la documentation. Les fichiers HTML, les URLs et les chaînes HTML peuvent tous être convertis 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

Exemple : Filigrane conditionnel avec IronPDF et les instructions Switch

Considérons un scénario où vous avez un document PDF, et vous souhaitez appliquer différents filigranes en fonction du nombre de pages dans le document. Voici comment vous pouvez y parvenir en utilisant IronPDF en combinaison avec une instruction de commutation C# :

using IronPdf;
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;
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
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")

Voici le fichier PDF de sortie d'une page :

Conclusion

Dans ce tutoriel, nous avons exploré l'instruction switch case en C#, un moyen de prise de décision en programmation. Nous avons commencé par comprendre sa structure de base et nous l'avons comparée aux instructions if-else traditionnelles, en soulignant ses avantages en termes de lisibilité et de simplicité pour la gestion de conditions multiples.

Nous créons des cas de commutation simples, traitons divers scénarios avec le cas par défaut et explorons des fonctionnalités avancées telles que les expressions de commutation. L'application réelle des instructions de commutation a été démontrée à travers un exemple intégrant IronPDF pour le traitement dynamique des PDF, montrant comment les instructions de commutation peuvent être précieuses dans la boîte à outils d'un programmeur.

IronPDF propose un essai gratuit pour l'exploration des fonctionnalités, vous permettant de découvrir ses caractéristiques et fonctionnalités. Pour une utilisation continue et un accès complet à l'ensemble de ses outils, les licences IronPDF commencent à partir de $749, offrant une solution complète pour tous vos besoins de traitement PDF en C#.