C# Unions Discriminées (Comment ça fonctionne pour les développeurs)

Qu'est-ce qu'une Union Discriminée en 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

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 proprement, conduisant à une sécurité à la compilation, moins de bogues 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

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.

Simuler les Unions Discriminées en C# – Struct vs Enregistrement vs Classe

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 supporte parfaitement le filtrage par motif.
• Classes : Plus flexible avec l'héritage et les sémantiques de référence.
• Structs : Utile pour les types valeur, mais moins flexible lors de la manipulation de types de 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

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

Avantages de l'utilisation d'Unions Discriminées en C#

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

• Sécurité à la compilation : Vous attraperez 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 des actions avec des cas nommés.
• Séparation des préoccupations : Vous découplez les comportements basés sur les données plutôt que sur les hiérarchies de types.
• Facilité de refactorisation : Ajouter ou supprimer des 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 dans le cycle de vie d'un document (générer, enregistrer, envoyer par email).
• Modèles de permission : Représenter différents niveaux d'accès utilisateur.
• Systèmes de journalisation : Utiliser des types d'unions discriminées pour les niveaux de log (info, erreur, debug).
• Tests unitaires : Définir les actions de test comme des types d'union pour des arbres logiques maintenables.
• Options d'exportation : Représenter des cibles de sortie comme PDF, Excel, Word en tant qu'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;
'	}
'}

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.

Perspectives d'avenir – C# supportera-t-il un jour les Unions Discriminées Natives ?

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.

.NET développeurs intéressés par des constructions de langage modernes et conviviales fonctionnelles voudront suivre cela 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.