Comment puis-je créer une union discriminée en C# ?

Vous pouvez créer une union discriminée en C# en définissant une classe abstraite avec des sous-classes imbriquées. Chaque sous-classe représente un cas possible, tel qu'un état de succès ou d'erreur, et vous pouvez utiliser le pattern matching pour traiter ces cas.

Quel est le rôle de la bibliothèque IronPDF dans la gestion des unions discriminées?

La bibliothèque IronPDF peut être utilisée en conjonction avec les unions discriminées pour gérer les résultats de génération de PDF. En modélisant ces résultats comme des unions discriminées, vous pouvez garantir la sécurité des types et traiter à la fois les créations de PDF réussies et les erreurs éventuelles.

Comment le pattern matching améliore-t-il les unions discriminées en C# ?

Le pattern matching améliore les unions discriminées en C# en permettant aux développeurs de gérer élégamment chaque cas possible. Avec le pattern matching, vous pouvez gérer en toute sécurité différents résultats, garantissant que tous les scénarios sont couverts à la compilation.

Pourquoi les unions discriminées sont-elles bénéfiques pour la génération de PDF en C# ?

Les unions discriminées sont bénéfiques pour la génération de PDF en C# car elles offrent un moyen structuré de traiter les cas de succès et d'erreur. Cette approche garantit que les problèmes potentiels sont abordés à la compilation, réduisant ainsi les erreurs d'exécution lors de la création du PDF.

Les unions discriminées peuvent-elles être étendues pour une fonctionnalité supplémentaire en C# ?

Oui, les unions discriminées peuvent être étendues avec des fonctionnalités supplémentaires à l'aide de méthodes d'extension. Cela vous permet d'ajouter des comportements personnalisés, comme vérifier l'état de réussite d'une génération de PDF, sans modifier la structure de base.

Existe-t-il un moyen de simuler les unions discriminées en C# sans support natif?

Oui, même si C# ne prend pas en charge les unions discriminées de manière native, elles peuvent être simulées à l'aide des hiérarchies de classes. Une classe de base abstraite peut être utilisée avec des classes imbriquées pour représenter différents résultats possibles, tels que des cas de succès ou d'échec.

Comment les développeurs C# peuvent-ils gérer efficacement les erreurs lors de la génération de PDF ?

Les développeurs C# peuvent gérer efficacement les erreurs lors de la génération de PDF en utilisant des unions discriminées pour modéliser les résultats potentiels. Cette approche garantit que les erreurs sont abordées à la compilation, améliorant la fiabilité et la maintenance du code.

Quels sont les avantages d'utiliser IronPDF avec des unions discriminées pour les projets C# ?

L'utilisation d'IronPDF avec des unions discriminées dans les projets C# offre l'avantage d'une gestion robuste des erreurs lors de la génération de PDF. Cette combinaison permet de différencier clairement les opérations réussies et les erreurs, renforçant la sécurité et la fiabilité du code.

Comment les unions discriminées contribuent-elles à la sécurité des types en C# ?

Les unions discriminées contribuent à la sécurité des types en C# en garantissant que tous les cas possibles sont traités lors de la compilation. Cela réduit la probabilité d'erreurs d'exécution et rend le code plus prévisible et plus facile à maintenir.

La Bibliothèque PDF C#

Explore IronPDF Essai gratuit

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

MISES À JOUR POUR LES DÉVELOPPEURS

C# Union Discriminée (Comment ça fonctionne pour les développeurs)

Jacob Mellor

Updated: 28 juillet 2025

Unions discriminants, également connus sous le nom d'unions étiquetées ou de types somme, représentent un outil puissant pour modéliser des données pouvant prendre différentes formes, mais avec des cas possibles bien définis et limités. Bien que C# n'ait pas d'unions discriminantes natives comme certains autres langages (par exemple, F# ou Rust), vous pouvez simuler des unions discriminantes en utilisant plusieurs techniques dans le langage. Dans ce tutoriel, nous approfondirons les unions discriminantes, comment les implémenter en C#, et leur cas d'utilisation pratique avec la bibliothèque IronPDF.

Qu'est-ce qu'une Union Discriminante ?

En termes simples, une union discriminante est un type qui peut contenir l'une de plusieurs formes ou valeurs prédéfinies. Elle fournit un moyen de créer une structure typée qui encapsule différents types ou valeurs tout en garantissant que seuls les cas valides sont traités au moment de la compilation.

Imaginez un scénario où vous souhaitez représenter le résultat d'une opération. L'opération peut soit réussir en retournant des données, soit échouer en retournant un message d'erreur. Une union discriminante vous permettrait de représenter ces deux résultats possibles en un seul type.

Example: Simulating Discriminated Union in C#

Voici un exemple de la façon dont vous pouvez simuler une union discriminante en C# en utilisant une structure de classe :

// Define an abstract base class representing the operation result.
public abstract class OperationResult<t>
{
    // Private constructor to ensure the class cannot be instantiated directly.
    private OperationResult() { }

    // Nested class representing a successful operation result.
    public sealed class Success : OperationResult<t>
    {
        public T Value { get; }
        
        public Success(T value) => Value = value;

        public override string ToString() => $"Success: {Value}";
    }

    // Nested class representing a failed operation result.
    public sealed class Failure : OperationResult<t>
    {
        public string Error { get; }
        
        public Failure(string error) => Error = error;

        public override string ToString() => $"Failure: {Error}";
    }

    // Factory method to create a successful operation result.
    public static OperationResult<t> CreateSuccess(T value) => new Success(value);

    // Factory method to create a failed operation result.
    public static OperationResult<t> CreateFailure(string error) => new Failure(error);
}

// Define an abstract base class representing the operation result.
public abstract class OperationResult<t>
{
    // Private constructor to ensure the class cannot be instantiated directly.
    private OperationResult() { }

    // Nested class representing a successful operation result.
    public sealed class Success : OperationResult<t>
    {
        public T Value { get; }
        
        public Success(T value) => Value = value;

        public override string ToString() => $"Success: {Value}";
    }

    // Nested class representing a failed operation result.
    public sealed class Failure : OperationResult<t>
    {
        public string Error { get; }
        
        public Failure(string error) => Error = error;

        public override string ToString() => $"Failure: {Error}";
    }

    // Factory method to create a successful operation result.
    public static OperationResult<t> CreateSuccess(T value) => new Success(value);

    // Factory method to create a failed operation result.
    public static OperationResult<t> CreateFailure(string error) => new Failure(error);
}

Dans cet exemple, OperationResult<t> est une classe abstraite qui représente notre type d'union discriminée. Il peut s'agir soit d'un Success avec une valeur de type T soit d'un Failure avec un message d'erreur. Le constructeur privé garantit que les instances de cette classe ne peuvent être créées qu'à travers les cas prédéfinis.

Utilisation de la Correspondance de Modèles avec les Unions Discriminantes

C# fournit de puissantes capacités de correspondance de modèles qui fonctionnent bien avec les unions discriminantes. Étendons notre exemple OperationResult<t> avec une méthode qui gère différents cas à l'aide d'une expression switch.

// Method to handle the result using pattern matching.
public string HandleResult(OperationResult<int> result) =>
    result switch
    {
        OperationResult<int>.Success success => $"Operation succeeded with value: {success.Value}",
        OperationResult<int>.Failure failure => $"Operation failed with error: {failure.Error}",
        _ => throw new InvalidOperationException("Unexpected result type")
    };

// Method to handle the result using pattern matching.
public string HandleResult(OperationResult<int> result) =>
    result switch
    {
        OperationResult<int>.Success success => $"Operation succeeded with value: {success.Value}",
        OperationResult<int>.Failure failure => $"Operation failed with error: {failure.Error}",
        _ => throw new InvalidOperationException("Unexpected result type")
    };

' Method to handle the result using pattern matching.
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'public string HandleResult(OperationResult<int> result) => result switch
'	{
'		OperationResult<int>.Success success => $"Operation succeeded with value: {success.Value}",
'		OperationResult<int>.Failure failure => $"Operation failed with error: {failure.Error}",
'		_ => throw new InvalidOperationException("Unexpected result type")
'	};

' Method to handle the result using pattern matching.
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'public string HandleResult(OperationResult<int> result) => result switch
'	{
'		OperationResult<int>.Success success => $"Operation succeeded with value: {success.Value}",
'		OperationResult<int>.Failure failure => $"Operation failed with error: {failure.Error}",
'		_ => throw new InvalidOperationException("Unexpected result type")
'	};

L'expression switch ici gère à la fois les cas Success et Failure de l'OperationResult<int>. Cela garantit que tous les cas possibles sont couverts au moment de la compilation, offrant ainsi une sécurité de type et réduisant le risque d'erreurs à l'exécution.

Méthodes d'Extension pour les Unions Discriminantes

Vous pouvez étendre la fonctionnalité des unions discriminantes en utilisant des méthodes d'extension. Par exemple, créons une méthode d'extension pour notre OperationResult<t> afin de déterminer si le résultat est un succès :

// Static class to hold extension methods for OperationResult<t>.
public static class OperationResultExtensions
{
    // Extension method to check if the operation result indicates success. 
    public static bool IsSuccess<t>(this OperationResult<t> result) =>
        result is OperationResult<t>.Success;
}

// Static class to hold extension methods for OperationResult<t>.
public static class OperationResultExtensions
{
    // Extension method to check if the operation result indicates success. 
    public static bool IsSuccess<t>(this OperationResult<t> result) =>
        result is OperationResult<t>.Success;
}

' Static class to hold extension methods for OperationResult(Of T).
Public Module OperationResultExtensions

    ' Extension method to check if the operation result indicates success.
    <System.Runtime.CompilerServices.Extension>
    Public Function IsSuccess(Of T)(ByVal result As OperationResult(Of T)) As Boolean
        Return TypeOf result Is OperationResult(Of T).Success
    End Function

End Module

' Static class to hold extension methods for OperationResult(Of T).
Public Module OperationResultExtensions

    ' Extension method to check if the operation result indicates success.
    <System.Runtime.CompilerServices.Extension>
    Public Function IsSuccess(Of T)(ByVal result As OperationResult(Of T)) As Boolean
        Return TypeOf result Is OperationResult(Of T).Success
    End Function

End Module

Cette méthode statique vérifie si le résultat est une instance du cas Success.

Native Support for Discriminated Unions in C#

C# n'a pas de support natif pour les unions discriminantes comme certains autres langages, mais des discussions sont en cours dans la communauté pour ajouter une telle fonctionnalité. Les unions discriminantes natives rendraient plus facile la définition et le travail avec les types d'unions sans avoir besoin de s'appuyer sur des hiérarchies de classes.

Erreurs du Compilateur et Sécurité de Type

L'un des principaux avantages des unions discriminantes est la sécurité de type qu'elles procurent. Puisque tous les cas possibles sont connus au moment de la compilation, le compilateur peut imposer que tous les cas soient traités. Cela entraîne moins d'erreurs à l'exécution et rend le code moins sujet aux erreurs.

Par exemple, si vous oubliez de traiter un cas spécifique dans une instruction switch, le compilateur produira une erreur, vous incitant à résoudre le cas manquant. Cela est particulièrement utile lors de la gestion de structures de données complexes avec plusieurs cas possibles.

Using IronPDF with Discriminated Unions in C#

C# Union Discriminée (Comment cela fonctionne pour les développeurs) : Figure 1 - IronPDF

IronPDF est une bibliothèque PDF en C# qui aide les développeurs à créer des fichiers PDF à partir de HTML et leur permet de modifier les fichiers PDF sans aucune difficulté. Lors du travail avec des PDF en C#, vous pouvez intégrer IronPDF avec des unions discriminantes pour gérer différents scénarios lors de la génération ou du traitement des fichiers PDF. Par exemple, vous pourriez avoir un processus qui génère soit un PDF avec succès, soit qui rencontre une erreur. Les unions discriminantes vous permettent de modéliser ce processus clairement. Créons un exemple simple où nous générons un PDF à l'aide d'IronPDF et retournons le résultat sous forme d'union discriminante.

// Using directives for necessary namespaces.
using IronPdf;
using System;

// Define an abstract base class representing the PDF generation result.
public abstract class PdfResult
{
    // Private constructor to ensure the class cannot be instantiated directly.
    private PdfResult() { }

    // Nested class representing a successful PDF generation result.
    public sealed class Success : PdfResult
    {
        public PdfDocument Pdf { get; }
        
        public Success(PdfDocument pdf) => Pdf = pdf;

        public override string ToString() => "PDF generation succeeded";
    }

    // Nested class representing a failed PDF generation result.
    public sealed class Failure : PdfResult
    {
        public string ErrorMessage { get; }
        
        public Failure(string errorMessage) => ErrorMessage = errorMessage;

        public override string ToString() => $"PDF generation failed: {ErrorMessage}";
    }

    // Factory method to create a successful PDF result.
    public static PdfResult CreateSuccess(PdfDocument pdf) => new Success(pdf);

    // Factory method to create a failed PDF result.
    public static PdfResult CreateFailure(string errorMessage) => new Failure(errorMessage);
}

// Class to generate PDFs using IronPDF.
public class PdfGenerator
{
    // Method to generate a PDF from HTML content and return the result as a PdfResult.
    public PdfResult GeneratePdf(string htmlContent)
    {
        try
        {
            // Create a new ChromePdfRenderer instance.
            var renderer = new ChromePdfRenderer();

            // Attempt to render the HTML content as a PDF.
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);

            // Return a success result with the generated PDF.
            return PdfResult.CreateSuccess(pdf);
        }
        catch (Exception ex)
        {
            // Return a failure result with the error message if an exception occurs.
            return PdfResult.CreateFailure(ex.Message);
        }
    }
}

// Using directives for necessary namespaces.
using IronPdf;
using System;

// Define an abstract base class representing the PDF generation result.
public abstract class PdfResult
{
    // Private constructor to ensure the class cannot be instantiated directly.
    private PdfResult() { }

    // Nested class representing a successful PDF generation result.
    public sealed class Success : PdfResult
    {
        public PdfDocument Pdf { get; }
        
        public Success(PdfDocument pdf) => Pdf = pdf;

        public override string ToString() => "PDF generation succeeded";
    }

    // Nested class representing a failed PDF generation result.
    public sealed class Failure : PdfResult
    {
        public string ErrorMessage { get; }
        
        public Failure(string errorMessage) => ErrorMessage = errorMessage;

        public override string ToString() => $"PDF generation failed: {ErrorMessage}";
    }

    // Factory method to create a successful PDF result.
    public static PdfResult CreateSuccess(PdfDocument pdf) => new Success(pdf);

    // Factory method to create a failed PDF result.
    public static PdfResult CreateFailure(string errorMessage) => new Failure(errorMessage);
}

// Class to generate PDFs using IronPDF.
public class PdfGenerator
{
    // Method to generate a PDF from HTML content and return the result as a PdfResult.
    public PdfResult GeneratePdf(string htmlContent)
    {
        try
        {
            // Create a new ChromePdfRenderer instance.
            var renderer = new ChromePdfRenderer();

            // Attempt to render the HTML content as a PDF.
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);

            // Return a success result with the generated PDF.
            return PdfResult.CreateSuccess(pdf);
        }
        catch (Exception ex)
        {
            // Return a failure result with the error message if an exception occurs.
            return PdfResult.CreateFailure(ex.Message);
        }
    }
}

' Using directives for necessary namespaces.
Imports IronPdf
Imports System

' Define an abstract base class representing the PDF generation result.
Public MustInherit Class PdfResult
    ' Private constructor to ensure the class cannot be instantiated directly.
    Private Sub New()
    End Sub

    ' Nested class representing a successful PDF generation result.
    Public NotInheritable Class Success
        Inherits PdfResult
        Public ReadOnly Property Pdf As PdfDocument

        Public Sub New(pdf As PdfDocument)
            Me.Pdf = pdf
        End Sub

        Public Overrides Function ToString() As String
            Return "PDF generation succeeded"
        End Function
    End Class

    ' Nested class representing a failed PDF generation result.
    Public NotInheritable Class Failure
        Inherits PdfResult
        Public ReadOnly Property ErrorMessage As String

        Public Sub New(errorMessage As String)
            Me.ErrorMessage = errorMessage
        End Sub

        Public Overrides Function ToString() As String
            Return $"PDF generation failed: {ErrorMessage}"
        End Function
    End Class

    ' Factory method to create a successful PDF result.
    Public Shared Function CreateSuccess(pdf As PdfDocument) As PdfResult
        Return New Success(pdf)
    End Function

    ' Factory method to create a failed PDF result.
    Public Shared Function CreateFailure(errorMessage As String) As PdfResult
        Return New Failure(errorMessage)
    End Function
End Class

' Class to generate PDFs using IronPDF.
Public Class PdfGenerator
    ' Method to generate a PDF from HTML content and return the result as a PdfResult.
    Public Function GeneratePdf(htmlContent As String) As PdfResult
        Try
            ' Create a new ChromePdfRenderer instance.
            Dim renderer = New ChromePdfRenderer()

            ' Attempt to render the HTML content as a PDF.
            Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

            ' Return a success result with the generated PDF.
            Return PdfResult.CreateSuccess(pdf)
        Catch ex As Exception
            ' Return a failure result with the error message if an exception occurs.
            Return PdfResult.CreateFailure(ex.Message)
        End Try
    End Function
End Class

' Using directives for necessary namespaces.
Imports IronPdf
Imports System

' Define an abstract base class representing the PDF generation result.
Public MustInherit Class PdfResult
    ' Private constructor to ensure the class cannot be instantiated directly.
    Private Sub New()
    End Sub

    ' Nested class representing a successful PDF generation result.
    Public NotInheritable Class Success
        Inherits PdfResult
        Public ReadOnly Property Pdf As PdfDocument

        Public Sub New(pdf As PdfDocument)
            Me.Pdf = pdf
        End Sub

        Public Overrides Function ToString() As String
            Return "PDF generation succeeded"
        End Function
    End Class

    ' Nested class representing a failed PDF generation result.
    Public NotInheritable Class Failure
        Inherits PdfResult
        Public ReadOnly Property ErrorMessage As String

        Public Sub New(errorMessage As String)
            Me.ErrorMessage = errorMessage
        End Sub

        Public Overrides Function ToString() As String
            Return $"PDF generation failed: {ErrorMessage}"
        End Function
    End Class

    ' Factory method to create a successful PDF result.
    Public Shared Function CreateSuccess(pdf As PdfDocument) As PdfResult
        Return New Success(pdf)
    End Function

    ' Factory method to create a failed PDF result.
    Public Shared Function CreateFailure(errorMessage As String) As PdfResult
        Return New Failure(errorMessage)
    End Function
End Class

' Class to generate PDFs using IronPDF.
Public Class PdfGenerator
    ' Method to generate a PDF from HTML content and return the result as a PdfResult.
    Public Function GeneratePdf(htmlContent As String) As PdfResult
        Try
            ' Create a new ChromePdfRenderer instance.
            Dim renderer = New ChromePdfRenderer()

            ' Attempt to render the HTML content as a PDF.
            Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

            ' Return a success result with the generated PDF.
            Return PdfResult.CreateSuccess(pdf)
        Catch ex As Exception
            ' Return a failure result with the error message if an exception occurs.
            Return PdfResult.CreateFailure(ex.Message)
        End Try
    End Function
End Class

La classe PdfResult représente une union discriminée avec deux cas : Success et Failure. Le cas Success contient un PdfDocument, tandis que le cas Failure contient un message d'erreur. La méthode GeneratePdf prend une chaîne HTML, tente de générer un PDF en utilisant IronPDF, et retourne le résultat en tant que PdfResult. Si la génération du PDF réussit, elle retourne le cas Success avec le PDF généré. Si une exception se produit, elle retourne le cas Failure avec le message d'erreur.

Conclusion

Les unions discriminantes en C# fournissent un moyen puissant et flexible de modéliser des données avec plusieurs cas possibles. Bien que C# ne prenne pas en charge les unions discriminantes, vous pouvez les simuler en utilisant des hiérarchies de classes, la correspondance de modèles et d'autres techniques. Le code résultant est plus typé, moins sujet aux erreurs et plus facile à maintenir.

IronPDF offre un essai gratuit pour vous aider à vous familiariser avec le logiciel sans frais initiaux. Vous pouvez explorer toutes les fonctionnalités et voir comment elles correspondent à vos besoins. Après votre essai, des licences sont disponibles à partir de $999.

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...