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

Lesinstruction switch en C# offre une alternative plus rationnelle et plus 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 le montre le programme ci-dessus.
• case value1 : Il s'agit des différentes valeurs ou conditions que vous vérifiez pour la variable.
• break : Ce mot-clé est utilisé pour quitter le bloc de commutation une fois qu'un cas correspondant est exécuté.
• Déclaration par défaut : Ce bloc facultatif 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. La casse par défaut est déclarée en utilisant le mot-clé default, suivi de 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 autre que 1 à 7, le cas par défaut est exécuté, fixant dayName à "Invalid day".

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, prévoyez 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, comme 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 trait de soulignement(_) représente le cas par défaut dans les expressions de commutation, fonctionnant de la même manière que le bloc par défaut dans les instructions de commutation 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 du commutateur catégorise succinctement la température, avec le cas par défaut(_) couvrant tout scénario ne correspondant pas aux 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"
'};

Déclaration d'interrupteur C# vs. expression d'interrupteur

L'instruction Switch de 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 de commutation : Introduite dans C# 8.0, cette expression 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 ;

Découvrez les fonctionnalités d'IronPDF est une bibliothèque PDF .NET permettant de créer, d'éditer et de 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é clé d'IronPDF est la conversionHTML vers PDF avec mises en page et styles, tout en conservant 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 dans lequel vous avez un document PDF et vous voulezappliquer différents filigranes en fonction du nombre de pages en fonction du nombre de pages du 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 offre un service deessai gratuit pour l'exploration des fonctionnalitésvous pouvez ainsi découvrir ses caractéristiques et ses fonctionnalités. Pour une utilisation continue et un accès à sa suite complète d'outils, les licences IronPDF commencent à partir de $749, fournissant une solution complète pour tous vos besoins de traitement PDF en C#.