Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Gestion de Motifs de Commutation C#
.NET AIDE

C# Switch Pattern Matching (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Travailler avec des fichiers PDF en C# implique souvent de gérer différents types de documents, actions ou sources de données. Traditionnellement, les développeurs peuvent s'appuyer sur de longues chaînes if-else ou des déclarations switch imbriquées pour gérer diverses valeurs d'entrée et sorties. Mais avec les fonctionnalités modernes de C# comme le switch pattern matching, votre code peut devenir bien plus élégant, lisible et maintenable.

Combiné avec une bibliothèque PDF puissante comme IronPDF, le switch pattern matching vous permet de construire une logique plus intelligente et plus propre pour le traitement des documents. Dans cet article, nous allons explorer comment utiliser les fonctionnalités avancées de pattern matching de C# — telles que les patterns de type, les patterns de propriété et les patterns relationnels — en parallèle avec IronPDF pour simplifier vos flux de travail de génération de PDF.

Qu'est-ce que le Switch Pattern Matching en C# ?

Le switch pattern matching est une fonctionnalité introduite dans C# 7 et continuellement améliorée dans les versions ultérieures. Contrairement aux instructions switch traditionnelles qui ne correspondent qu'à des valeurs constantes, le pattern matching vous permet d'évaluer des types, des propriétés et des conditions au sein d'une seule expression. L'exemple suivant montre comment cette fonctionnalité fonctionne.

Syntaxe de l'Exemple

switch (input)
{
    case int i when i > 0:
        Console.WriteLine("Positive integer");
        break;
    case string s:
        Console.WriteLine($"It's a string: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}
switch (input)
{
    case int i when i > 0:
        Console.WriteLine("Positive integer");
        break;
    case string s:
        Console.WriteLine($"It's a string: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}
Select Case input
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case int i when i > 0:
	Case Integer i [when] i > 0
		Console.WriteLine("Positive integer")
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case string s:
	Case String s
		Console.WriteLine($"It's a string: {s}")
	Case Else
		Console.WriteLine("Unknown type")
End Select
$vbLabelText   $csharpLabel

Ce code utilise des patterns de type, des opérateurs relationnels et un pattern de constante null pour gérer plusieurs cas de manière concise. Cette technique améliore considérablement la lisibilité du code avec une syntaxe plus concise et prend en charge une logique plus complexe.

Pourquoi Combiner le Switch Pattern Matching avec IronPDF ?

C# Switch Pattern Matching (Comment ça fonctionne pour les développeurs) : Figure 1 - Page d'accueil de IronPDF

IronPDF est un composant .NET puissant pour générer et manipuler des PDFs à partir de HTML, d'images ou de texte brut. De nombreux cas d'utilisation réels impliquent de traiter différents modèles d'entrée : certains documents peuvent provenir d'URL, d'autres de chaînes HTML, et d'autres de téléchargements de fichiers.

Plutôt que de tester des expressions avec des conditions if maladroites, le switch pattern matching vous permet de prendre en charge la logique basée sur les modèles efficacement. Il vous permet de définir comment votre application réagit à différents types d'objets, des constantes spécifiées ou même des expressions booléennes — en utilisant l'expression d'entrée elle-même pour piloter le flux de travail.

Cas d'Utilisation Courants dans IronPDF avec Pattern Matching

Dans l'exemple précédent, nous avons regardé à quoi ressemble la syntaxe de base, mais regardons maintenant à l'œuvre. Les exemples de code suivants sont des tâches PDF réelles qui bénéficient de la combinaison d'IronPDF avec le pattern matching de C#.

1. Gérer Plusieurs Formats d'Entrée avec des Patterns de Type et de Propriété

Disons que votre méthode accepte divers formats d'entrée : HTML, un URI ou un fichier .html local. En utilisant des patterns de type, de propriété et des patterns null, vous pouvez distinguer ces cas sans effort.

using System;
using System.IO;
using IronPdf;
class Program
{
    static void Main()
    {
        object input = new Uri("https://example.com"); // Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
        var renderer = new ChromePdfRenderer();
        PdfDocument pdfDoc = input switch
        {
            string html when html.StartsWith("<html>") =>
                renderer.RenderHtmlAsPdf(html),
            Uri url =>
                renderer.RenderUrlAsPdf(url.ToString()),
            FileInfo { Extension: ".html" } file =>
                renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
            null => throw new ArgumentNullException("Input was null."),
            _ => throw new ArgumentException("Unsupported input type for PDF conversion.")
        };
        pdfDoc.SaveAs("example-input-types.pdf");
        Console.WriteLine("PDF created: example-input-types.pdf");
    }
}
using System;
using System.IO;
using IronPdf;
class Program
{
    static void Main()
    {
        object input = new Uri("https://example.com"); // Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
        var renderer = new ChromePdfRenderer();
        PdfDocument pdfDoc = input switch
        {
            string html when html.StartsWith("<html>") =>
                renderer.RenderHtmlAsPdf(html),
            Uri url =>
                renderer.RenderUrlAsPdf(url.ToString()),
            FileInfo { Extension: ".html" } file =>
                renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
            null => throw new ArgumentNullException("Input was null."),
            _ => throw new ArgumentException("Unsupported input type for PDF conversion.")
        };
        pdfDoc.SaveAs("example-input-types.pdf");
        Console.WriteLine("PDF created: example-input-types.pdf");
    }
}
Imports System
Imports System.IO
Imports IronPdf
Friend Class Program
	Shared Sub Main()
		Dim input As Object = New Uri("https://example.com") ' Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
		Dim renderer = New ChromePdfRenderer()
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		PdfDocument pdfDoc = input switch
'		{
'			string html when html.StartsWith("<html>") => renderer.RenderHtmlAsPdf(html),
'			Uri url =>
'				renderer.RenderUrlAsPdf(url.ToString()),
'			FileInfo { Extension: ".html" } file =>
'				renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
'			null => throw new ArgumentNullException("Input was null."),
'			_ => throw new ArgumentException("Unsupported input type for PDF conversion.")
'		};
		pdfDoc.SaveAs("example-input-types.pdf")
		Console.WriteLine("PDF created: example-input-types.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Ici, le pattern de propriété (FileInfo { Extension: ".html" }) et le pattern de constante null (case null) rendent la logique plus expressive et robuste.

2. Formater Dynamiquement les PDFs avec des Patterns Positionnels et de Déclaration

Supposons que vous utilisiez un enregistrement PdfRequest qui inclut une chaîne de format. Vous pouvez appliquer des patterns positionnels, des patterns de déclaration et des constantes de chaîne pour personnaliser le formatage des PDF.

using System;
using IronPdf;
public record PdfRequest(string Title, string Content, string Format);
class Program
{
    static void Main()
    {
        PdfRequest request = new("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4");
        var renderer = new ChromePdfRenderer();
        // Use fully qualified enum to avoid IronWord conflict
        renderer.RenderingOptions = request switch
        {
            PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.A4
            },
            PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
            },
            _ => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
            }
        };
        var pdf = renderer.RenderHtmlAsPdf(request.Content);
        pdf.SaveAs("example-formatted.pdf");
        Console.WriteLine("PDF created: example-formatted.pdf");
    }
}
using System;
using IronPdf;
public record PdfRequest(string Title, string Content, string Format);
class Program
{
    static void Main()
    {
        PdfRequest request = new("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4");
        var renderer = new ChromePdfRenderer();
        // Use fully qualified enum to avoid IronWord conflict
        renderer.RenderingOptions = request switch
        {
            PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.A4
            },
            PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
            },
            _ => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
            }
        };
        var pdf = renderer.RenderHtmlAsPdf(request.Content);
        pdf.SaveAs("example-formatted.pdf");
        Console.WriteLine("PDF created: example-formatted.pdf");
    }
}
Imports System
Imports IronPdf
'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record PdfRequest(string Title, string Content, string Format)
Friend Class Program
	Shared Sub Main()
		Dim request As New PdfRequest("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4")
		Dim renderer = New ChromePdfRenderer()
		' Use fully qualified enum to avoid IronWord conflict
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		renderer.RenderingOptions = request switch
'		{
'			PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.A4
'			},
'			PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
'			},
'			_ => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
'			}
'		};
		Dim pdf = renderer.RenderHtmlAsPdf(request.Content)
		pdf.SaveAs("example-formatted.pdf")
		Console.WriteLine("PDF created: example-formatted.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Cet usage démontre comment l'expression correspond à la propriété correspondante dans l'enregistrement, suivant des modèles logiques basés sur des valeurs attendues.

Tailles de Sortie

C# Switch Pattern Matching (Comment ça fonctionne pour les développeurs) : Figure 2 - Différence de taille dans les sorties PDF

3. PDFs Basés sur les Rôles Utilisant des Patterns Var et Not

Utilisez des patterns var et not pour gérer les rôles des utilisateurs tout en évitant les états nuls ou inattendus.

using System;
using IronPdf;
public abstract record UserRole;
public record Admin(string Email) : UserRole;
public record Viewer(string Email) : UserRole;
public record Guest() : UserRole;
class Program
{
    static void Main()
    {
        UserRole currentUser = new Admin("admin@example.com"); // Try changing to Viewer or Guest
        var pdf = currentUser switch
        {
            Admin { Email: var email } =>
                new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
            Viewer =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
            Guest =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
            not null =>
                throw new UnauthorizedAccessException("Unknown role type."),
            null =>
                throw new ArgumentNullException("Role cannot be null.")
        };
        pdf.SaveAs("example-role.pdf");
        Console.WriteLine("PDF created: example-role.pdf");
    }
}
using System;
using IronPdf;
public abstract record UserRole;
public record Admin(string Email) : UserRole;
public record Viewer(string Email) : UserRole;
public record Guest() : UserRole;
class Program
{
    static void Main()
    {
        UserRole currentUser = new Admin("admin@example.com"); // Try changing to Viewer or Guest
        var pdf = currentUser switch
        {
            Admin { Email: var email } =>
                new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
            Viewer =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
            Guest =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
            not null =>
                throw new UnauthorizedAccessException("Unknown role type."),
            null =>
                throw new ArgumentNullException("Role cannot be null.")
        };
        pdf.SaveAs("example-role.pdf");
        Console.WriteLine("PDF created: example-role.pdf");
    }
}
Imports System
Imports IronPdf
Public MustOverride ReadOnly Property UserRole() As record
public record Admin(String Email) : UserRole
public record Viewer(String Email) : UserRole
public record Guest() : UserRole
Dim Program As class
If True Then
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	static void Main()
'	{
'		UserRole currentUser = New Admin("admin@example.com"); ' Try changing to Viewer or Guest
''INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
''		var pdf = currentUser switch
''		{
''			Admin { Email: var email } => new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
''			Viewer =>
''				new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
''			Guest =>
''				new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
''			not null =>
''				throw new UnauthorizedAccessException("Unknown role type."),
''			null =>
''				throw new ArgumentNullException("Role cannot be null.")
''		};
'		pdf.SaveAs("example-role.pdf");
'		Console.WriteLine("PDF created: example-role.pdf");
'	}
End If
$vbLabelText   $csharpLabel

Cette structure améliore la sécurité et la lisibilité du code, tout en profitant des déclarations de variables temporaires comme var email. L'image suivante montre les différents documents PDF créés en fonction des différentes valeurs d'entrée.

C# Switch Pattern Matching (Comment ça fonctionne pour les développeurs) : Figure 3 - Sortie basée sur les rôles

4. Pattern Matching Relationnel Basé sur les Données Utilisateur

Besoin de générer différents PDFs selon les niveaux d'utilisateur ? Essayez d'utiliser deux patterns relationnels pour vérifier si l'entrée se situe dans une certaine fourchette.

using System;
using IronPdf;
class Program
{
    static void Main()
    {
        int userScore = 85; // Try other values: 45, 70, 101
        string message = userScore switch
        {
            < 60 => "Needs Improvement",
            >= 60 and < 80 => "Satisfactory",
            >= 80 and <= 100 => "Excellent",
            _ => "Invalid score"
        };
        var html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>";
        var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
        pdf.SaveAs("example-score.pdf");
        Console.WriteLine("PDF created: example-score.pdf");
    }
}
using System;
using IronPdf;
class Program
{
    static void Main()
    {
        int userScore = 85; // Try other values: 45, 70, 101
        string message = userScore switch
        {
            < 60 => "Needs Improvement",
            >= 60 and < 80 => "Satisfactory",
            >= 80 and <= 100 => "Excellent",
            _ => "Invalid score"
        };
        var html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>";
        var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
        pdf.SaveAs("example-score.pdf");
        Console.WriteLine("PDF created: example-score.pdf");
    }
}
Imports System
Imports IronPdf
Friend Class Program
	Shared Sub Main()
		Dim userScore As Integer = 85 ' Try other values: 45, 70, 101
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		string message = userScore switch
'		{
'			< 60 => "Needs Improvement",
'			>= 60 and < 80 => "Satisfactory",
'			>= 80 and <= 100 => "Excellent",
'			_ => "Invalid score"
'		};
		Dim html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>"
		Dim pdf = (New ChromePdfRenderer()).RenderHtmlAsPdf(html)
		pdf.SaveAs("example-score.pdf")
		Console.WriteLine("PDF created: example-score.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Les opérateurs relationnels et les expressions booléennes gardent le code concis et expressif.

Sortie

C# Switch Pattern Matching (Comment ça fonctionne pour les développeurs) : Figure 4 - Sortie basée sur le score

Conseils pour Implémenter Ce Modèle Dans Vos Projets

C# Switch Pattern Matching (Comment ça fonctionne pour les développeurs) : Figure 5 - Cheat Sheet sur le Pattern Matching en C#

  • Utilisez des types enregistrement pour des objets de données propres et immuables.
  • Privilégiez les expressions switch sur les arbres if-else pour une logique plus propre.
  • Utilisez les patterns not et les patterns de suppression (_) pour ignorer les correspondances non pertinentes.
  • Ajoutez des cas par défaut pour intercepter les entrées inconnues tôt.
  • Séparez les cas complexes dans des méthodes auxiliaires pour plus de lisibilité.

Avis Réels

  • Code plus Propre : Plus besoin de blocs if-else ou switch-case profondément imbriqués
  • Test plus Facile : Des cas de modèle isolés simplifient les tests unitaires
  • Flexibilité : Étendez facilement la logique lors de l'ajout de nouveaux types d'entrée
  • Meilleure Séparation des Préoccupations : Concentrez la logique uniquement sur la transformation entrée/sortie

Conclusion : Modernisez Votre Logique PDF

Le switch pattern matching est plus qu'une simple amélioration syntaxique, c'est un paradigme puissant pour écrire un code plus sûr et plus expressif. Combiné avec les capacités de rendu flexibles d'IronPDF, vous pouvez créer des pipelines de génération de documents plus intelligents et plus évolutifs avec un code minimal.

Que vous construisiez un générateur de rapports, un visualiseur de documents ou un système de modèles dynamiques, essayez d'ajouter le pattern matching à votre implémentation IronPDF. Vous verrez rapidement les avantages en termes de clarté, de contrôle et de maintenabilité.

Voulez-vous Essayer IronPDF Vous-même ?

Téléchargez l'essai gratuit pour essayer par vous-même les fonctionnalités puissantes d'IronPDF avant d'acheter une licence.

Questions Fréquemment Posées

Comment le traitement de motifs de commutation C# peut-il être appliqué au traitement de documents ?

Le traitement de motifs de commutation en C# peut être utilisé pour simplifier la logique de prise de décision complexe. Lorsqu'il est intégré à une bibliothèque PDF comme IronPDF, il permet aux développeurs de gérer les tâches de traitement de documents plus efficacement en rationalisant la logique de décision et en améliorant la lisibilité du code.

Quels sont les avantages de l'utilisation du traitement de motifs de commutation par rapport aux instructions if-else traditionnelles ?

Le traitement de motifs de commutation offre une manière plus concise et lisible de gérer plusieurs conditions comparé aux instructions if-else traditionnelles. Il améliore la maintenabilité du code C#, surtout lors de la gestion de tâches complexes de traitement de documents utilisant IronPDF.

Comment le traitement de motifs de commutation facilite-t-il l'automatisation des documents PDF ?

Le traitement de motifs de commutation facilite l'automatisation des documents PDF en permettant aux développeurs de construire une logique plus propre pour gérer diverses actions documentaires et types de données. Lorsqu'il est utilisé avec IronPDF, il aide à automatiser les flux de travail et rationaliser les processus d'extraction de données.

Le traitement de motifs de commutation peut-il gérer des flux de travail documentaires complexes en C# ?

Oui, le traitement de motifs de commutation est bien adapté pour gérer des flux de travail documentaires complexes en C#. Il simplifie la logique requise pour gérer différents types de documents et actions, surtout lorsqu'il est utilisé avec des bibliothèques robustes comme IronPDF.

Comment implémentez-vous le traitement de motifs de commutation dans une application de traitement PDF en C# ?

Dans une application de traitement PDF en C#, vous pouvez implémenter le traitement de motifs de commutation en utilisant l'instruction switch avec une syntaxe de traitement de motifs pour gérer différents types de documents ou conditions de traitement. IronPDF peut être utilisé pour gérer les tâches de manipulation PDF réelles.

Quels défis les développeurs peuvent-ils rencontrer lors de l'utilisation du traitement de motifs de commutation en C# ?

Les développeurs peuvent rencontrer des défis avec le traitement de motifs de commutation lorsqu'ils traitent des motifs dynamiques ou basés sur l'exécution qui nécessitent une logique plus complexe. Cependant, lorsqu'il est utilisé correctement avec une bibliothèque comme IronPDF, il peut améliorer de manière significative l'efficacité du code.

Comment le traitement de motifs de commutation contribue-t-il à la maintenabilité du code ?

Le traitement de motifs de commutation contribue à la maintenabilité du code en fournissant un moyen clair et concis de gérer de multiples conditions. Cela réduit la complexité et rend le code plus facile à comprendre et à modifier, surtout dans les applications à grande échelle utilisant IronPDF.

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