En tant que développeur .NET travaillant avec la génération dynamique de PDF à l'aide de IronPDF, vous avez souvent besoin de représenter et de gérer une gamme de types spécifiques — pensez à différents types de données de document, de messages de journalisation, de rôles utilisateur ou d'options d'exportation. C'est là que le concept d'une union discriminée C# entre en jeu.

Même si C# n'a pas de support natif pour les unions discriminées comme le font F# ou Rust, vous pouvez toujours simuler efficacement des unions discriminées. Dans cet article de blog, nous allons plonger dans la façon de définir et d'utiliser un type discriminated union en C#, de démontrer comment l'appliquer avec IronPDF pour le traitement PDF en conditions réelles, et d'explorer les avantages que ce modèle offre — en particulier lorsqu'il est associé au filtrage par motif.

What Are Discriminated Unions in C#?

Les unions discriminées, également connues sous le nom d'unions étiquetées ou de types d'union, permettent à une variable de tenir une valeur d'un ensemble limité d'options possibles, où chaque option est associée à un identifiant de cas unique.

Dans d'autres langues comme F#, vous pourriez les définir en utilisant le mot clé union. C# ne fournit pas cette fonctionnalité de manière native, mais les développeurs peuvent utiliser des combinaisons intelligentes d'enregistrements, de classes et d'expressions switch pour les imiter.

Par exemple :

public abstract record PdfAction;
public record GenerateReport(string ReportName) : PdfAction;
public record LogError(string Message) : PdfAction;
public record ExportToExcel(string FilePath) : PdfAction;

public abstract record PdfAction;
public record GenerateReport(string ReportName) : PdfAction;
public record LogError(string Message) : PdfAction;
public record ExportToExcel(string FilePath) : PdfAction;

Public MustOverride ReadOnly Property PdfAction() As record
public record GenerateReport(String ReportName) : PdfAction
public record LogError(String Message) : PdfAction
public record ExportToExcel(String FilePath) : PdfAction

Public MustOverride ReadOnly Property PdfAction() As record
public record GenerateReport(String ReportName) : PdfAction
public record LogError(String Message) : PdfAction
public record ExportToExcel(String FilePath) : PdfAction

Chaque enregistrement ci-dessus représente un seul cas de l'union. Le type de base PdfAction est le discriminant.

Pourquoi les Unions Discriminées sont importantes dans les flux de travail IronPDF

Imaginez que vous construisez un générateur de rapport PDF à l'aide de IronPDF, et que vous devez effectuer différentes actions en fonction de l'entrée de l'utilisateur — peut-être générer un PDF, enregistrer une erreur ou exporter des données.

L'utilisation des unions discriminées en C# vous permet de représenter ces types d'options de manière claire, ce qui conduit à une sécurité à la compilation, moins de bugs et une logique plus claire.

Voici comment vous pourriez l'utiliser avec IronPDF :

void HandlePdfAction(PdfAction action)
{
    switch (action)
    {
        case GenerateReport r:
            var pdf = new IronPdf.HtmlToPdf().RenderHtmlAsPdf("<h1>" + r.ReportName + "</h1>");
            pdf.SaveAs(r.ReportName + ".pdf");
            break;
        case LogError e:
            Console.WriteLine("Logging Error: " + e.Message);
            break;
        case ExportToExcel x:
            Console.WriteLine("Exporting to Excel at " + x.FilePath);
            break;
        default:
            throw new NotSupportedException("Unknown action");
    }
}

void HandlePdfAction(PdfAction action)
{
    switch (action)
    {
        case GenerateReport r:
            var pdf = new IronPdf.HtmlToPdf().RenderHtmlAsPdf("<h1>" + r.ReportName + "</h1>");
            pdf.SaveAs(r.ReportName + ".pdf");
            break;
        case LogError e:
            Console.WriteLine("Logging Error: " + e.Message);
            break;
        case ExportToExcel x:
            Console.WriteLine("Exporting to Excel at " + x.FilePath);
            break;
        default:
            throw new NotSupportedException("Unknown action");
    }
}

Private Sub HandlePdfAction(ByVal action As PdfAction)
	Select Case action
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case GenerateReport r:
		Case GenerateReport r
			Dim pdf = (New IronPdf.HtmlToPdf()).RenderHtmlAsPdf("<h1>" & r.ReportName & "</h1>")
			pdf.SaveAs(r.ReportName & ".pdf")
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case LogError e:
		Case LogError e
			Console.WriteLine("Logging Error: " & e.Message)
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case ExportToExcel x:
		Case ExportToExcel x
			Console.WriteLine("Exporting to Excel at " & x.FilePath)
		Case Else
			Throw New NotSupportedException("Unknown action")
	End Select
End Sub

Private Sub HandlePdfAction(ByVal action As PdfAction)
	Select Case action
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case GenerateReport r:
		Case GenerateReport r
			Dim pdf = (New IronPdf.HtmlToPdf()).RenderHtmlAsPdf("<h1>" & r.ReportName & "</h1>")
			pdf.SaveAs(r.ReportName & ".pdf")
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case LogError e:
		Case LogError e
			Console.WriteLine("Logging Error: " & e.Message)
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case ExportToExcel x:
		Case ExportToExcel x
			Console.WriteLine("Exporting to Excel at " & x.FilePath)
		Case Else
			Throw New NotSupportedException("Unknown action")
	End Select
End Sub

Cette approche garde votre code organisé et robuste, et facilite aux développeurs la compréhension de toutes les options possibles en un seul endroit.

Simulating Discriminated Unions in C# – Struct vs. Record vs. Class

Bien que C# manque le mot clé union, vous pouvez simuler les unions discriminées en utilisant :

• Enregistrements : Idéal pour les données immuables et prend en charge la correspondance de modèles de manière claire.
• Classes : Plus de flexibilité grâce à l'héritage et à la sémantique de référence.
• Structures : utiles pour les types valeur, mais moins flexibles lorsqu'il s'agit de types référence ou d'héritage.

Si la performance et la disposition de la mémoire sont importantes — par exemple, dans la journalisation PDF à haut débit — vous pourriez envisager d'utiliser des unions discriminées struct avec précaution :

public interface IAction { }
public readonly struct SaveAction : IAction
{
    public string FileName { get; }
    public SaveAction(string fileName) => FileName = fileName;
}

public interface IAction { }
public readonly struct SaveAction : IAction
{
    public string FileName { get; }
    public SaveAction(string fileName) => FileName = fileName;
}

Public Interface IAction
End Interface
'INSTANT VB WARNING: VB has no equivalent to the C# readonly struct:
'ORIGINAL LINE: public readonly struct SaveAction : IAction
Public Structure SaveAction
	Implements IAction

	Public ReadOnly Property FileName() As String
	Public Sub New(ByVal fileName As String)
		Me.FileName = fileName
	End Sub
End Structure

Public Interface IAction
End Interface
'INSTANT VB WARNING: VB has no equivalent to the C# readonly struct:
'ORIGINAL LINE: public readonly struct SaveAction : IAction
Public Structure SaveAction
	Implements IAction

	Public ReadOnly Property FileName() As String
	Public Sub New(ByVal fileName As String)
		Me.FileName = fileName
	End Sub
End Structure

Remarque : Vous perdrez certains avantages de filtrage par motif avec les structs, surtout quand vous vous fiez aux expressions switch.

Benefits of Using Discriminated Unions in C#

Il y a plusieurs avantages clés à adopter ce modèle d'ingénierie logicielle :

• Sécurité à la compilation : vous détecterez les cas manquants dans une expression switch avant l'exécution.
• Logique plus claire : Il est plus facile d'écrire, de commenter et de raisonner sur des actions comportant des cas nommés.
• Séparation des préoccupations : vous découplez les comportements en fonction des données plutôt que des hiérarchies de types.
• Facilité de refactorisation : l'ajout ou la suppression de cas devient plus simple.

Associé à IronPDF, cela simplifie la gestion de l'entrée utilisateur, la logique de rendu, ou encore la création de modèles dynamiques avec différents pipelines de valeurs.

Quand utiliser les Unions Discriminées avec IronPDF

Voici quelques scénarios pratiques où ce modèle excelle :

• Flux de travail de génération de PDF : Différentes étapes du cycle de vie d'un document (générer, enregistrer, envoyer par courriel).
• Modèles d'autorisation : Représentent différents niveaux d'accès des utilisateurs.
• Systèmes de journalisation : Utilisez des types union discriminés pour les niveaux de journalisation (info, error, debug).
• Tests unitaires : définir les actions de test sous forme de types union pour des arbres logiques maintenables.
• Options d'exportation : Représenter les cibles de sortie telles que PDF, Excel, Word sous forme d'instances d'union.

Exemple – Gérer les Actions PDF à partir des Événements de l'UI

Disons que vous capturez des événements UI et souhaitez les diriger vers des tâches IronPDF à l'aide d'unions discriminées :

public abstract record UserAction;
public record GeneratePdf(string HtmlContent, string FileName) : UserAction;
public record ShowMessage(string Text) : UserAction;
public record ExitApplication() : UserAction;
void OnUserEvent(UserAction action)
{
    switch (action)
    {
        case GeneratePdf pdf:
            var renderer = new IronPdf.HtmlToPdf();
            var document = renderer.RenderHtmlAsPdf(pdf.HtmlContent);
            document.SaveAs(pdf.FileName);
            break;
        case ShowMessage msg:
            MessageBox.Show(msg.Text);
            break;
        case ExitApplication:
            Application.Exit();
            break;
    }
}

public abstract record UserAction;
public record GeneratePdf(string HtmlContent, string FileName) : UserAction;
public record ShowMessage(string Text) : UserAction;
public record ExitApplication() : UserAction;
void OnUserEvent(UserAction action)
{
    switch (action)
    {
        case GeneratePdf pdf:
            var renderer = new IronPdf.HtmlToPdf();
            var document = renderer.RenderHtmlAsPdf(pdf.HtmlContent);
            document.SaveAs(pdf.FileName);
            break;
        case ShowMessage msg:
            MessageBox.Show(msg.Text);
            break;
        case ExitApplication:
            Application.Exit();
            break;
    }
}

Public MustOverride ReadOnly Property UserAction() As record
public record GeneratePdf(String HtmlContent, String FileName) : UserAction
public record ShowMessage(String Text) : UserAction
public record ExitApplication() : UserAction
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'void OnUserEvent(UserAction action)
'{
'	switch (action)
'	{
'		case GeneratePdf pdf:
'			var renderer = New IronPdf.HtmlToPdf();
'			var document = renderer.RenderHtmlAsPdf(pdf.HtmlContent);
'			document.SaveAs(pdf.FileName);
'			break;
'		case ShowMessage msg:
'			MessageBox.Show(msg.Text);
'			break;
'		case ExitApplication:
'			Application.@Exit();
'			break;
'	}
'}

Public MustOverride ReadOnly Property UserAction() As record
public record GeneratePdf(String HtmlContent, String FileName) : UserAction
public record ShowMessage(String Text) : UserAction
public record ExitApplication() : UserAction
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'void OnUserEvent(UserAction action)
'{
'	switch (action)
'	{
'		case GeneratePdf pdf:
'			var renderer = New IronPdf.HtmlToPdf();
'			var document = renderer.RenderHtmlAsPdf(pdf.HtmlContent);
'			document.SaveAs(pdf.FileName);
'			break;
'		case ShowMessage msg:
'			MessageBox.Show(msg.Text);
'			break;
'		case ExitApplication:
'			Application.@Exit();
'			break;
'	}
'}

Cela vous permet de représenter des événements avec une logique claire et de réduire la dépendance aux types d'objet publics ou à la gestion trop dynamique.

Future Outlook – Will C# Ever Support Native Discriminated Unions?

Il y a déjà eu une proposition pour ajouter un support natif pour les unions discriminées en C#, en particulier avec la demande croissante pour des systèmes de types plus expressifs. Bien que le langage n'ait pas encore introduit un vrai mot clé union, C# continue d'évoluer — apportant des fonctionnalités comme les enregistrements, le filtrage par motif, et les expressions switch plus proches d'une fonctionnalité complète d'union discriminée.

Les développeurs .NET intéressés par des constructions de langage modernes et fonctionnelles voudront surveiller cet espace de près.

Conclusion

Utiliser les unions discriminées en C#, même sans support natif, peut significativement améliorer la façon dont vous structurez et représentez la logique dans les applications IronPDF. En utilisant des enregistrements, des expressions switch, et des classes de base, vous rendrez votre base de code plus lisible, maintenable, et résiliente aux erreurs — tout en débloquant un moyen plus déclaratif et expressif de gérer les tâches liées aux PDF.

Si vous êtes un ingénieur logiciel construisant des applications .NET modernes et flexibles, ce modèle est un must-have dans votre boîte à outils.

Essayez IronPDF Gratuitement Aujourd'hui

Prêt à porter votre génération de PDF C# au niveau supérieur ? Téléchargez IronPDF et commencez avec un essai gratuit. Que vous génériez des documents à partir de HTML, journalisiez des exportations, ou automatisiez des rapports à l'aide d'unions discriminées — IronPDF vous offre la puissance et la performance que votre application mérite.