Uniones Discriminadas, también conocidas como uniones etiquetadas o tipos suma, representan una herramienta poderosa para modelar datos que pueden tomar diferentes formas, pero con casos posibles bien definidos y limitados. Aunque C# no tiene uniones discriminadas nativas como otros lenguajes (por ejemplo, F# o Rust), se pueden simular usando varias técnicas en el lenguaje. En este tutorial, profundizaremos en las uniones discriminadas, cómo implementarlas en C#, y su caso de uso práctico con la biblioteca IronPDF.
En términos simples, una unión discriminada es un tipo que puede contener una de varias formas o valores predefinidos. Proporciona una manera de crear una estructura de tipo seguro que encapsula diferentes tipos o valores mientras asegura en tiempo de compilación que solo se manejen casos válidos.
Imagina un escenario en el que quieres representar el resultado de una operación. La operación puede tener éxito, devolviendo algunos datos, o fallar, devolviendo un mensaje de error. Una unión discriminada te permitiría representar estos dos posibles resultados en un solo tipo.
Aquí tienes un ejemplo de cómo puedes simular una unión discriminada en C# usando una estructura de clase:
// 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);
}En este ejemplo, OperationResult<t> es una clase abstracta que representa nuestro tipo de unión discriminada. Puede ser un Success con un valor de tipo T o un Failure con un mensaje de error. El constructor privado asegura que las instancias de dicha clase solo puedan crearse a través de los casos predefinidos.
C# proporciona potentes capacidades de coincidencia de patrones que funcionan bien con uniones discriminadas. Extendamos nuestro ejemplo de OperationResult<t> con un método que maneja diferentes casos utilizando una expresión 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.
'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")
' };La expresión switch aquí maneja tanto los casos Success y Failure del OperationResult<int>. Esto asegura que todos los posibles casos se cubran en tiempo de compilación, proporcionando seguridad de tipos y reduciendo el riesgo de errores en tiempo de ejecución.
Puedes extender la funcionalidad de las uniones discriminadas usando métodos de extensión. Por ejemplo, creemos un método de extensión para nuestro OperationResult<t> para determinar si el resultado es un éxito:
// 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 ModuleEste método estático verifica si el resultado es una instancia del caso Success.
C# no tiene soporte nativo para uniones discriminadas como algunos otros lenguajes, pero hay discusiones en curso en la comunidad sobre la adición de dicha característica. Las uniones discriminadas nativas harían más fácil definir y trabajar con tipos de unión sin la necesidad de depender de jerarquías de clases.
Uno de los beneficios clave de las uniones discriminadas es la seguridad de tipos que proporcionan. Dado que todos los posibles casos se conocen en tiempo de compilación, el compilador puede hacer cumplir que todos los casos sean manejados. Esto lleva a menos errores en tiempo de ejecución y hace que el código sea menos propenso a errores.
Por ejemplo, si olvidas manejar un caso específico en una instrucción switch, el compilador producirá un error, incitándote a abordar el caso faltante. Esto es especialmente útil cuando se trata de estructuras de datos complejas con múltiples casos posibles.
IronPDF es una biblioteca de PDF para C# que ayuda a los desarrolladores a crear archivos PDF desde HTML y les permite modificar archivos PDF sin ningún problema. Al trabajar con PDFs en C#, puedes integrar IronPDF con uniones discriminadas para manejar diferentes escenarios al generar o procesar archivos PDF. Por ejemplo, podrías tener un proceso que o bien genere exitosamente un PDF o encuentre un error. Las uniones discriminadas te permiten modelar claramente este proceso. Creamos un ejemplo simple donde generamos un PDF usando IronPDF y devolvemos el resultado como una unión discriminada.
// 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 ClassLa clase PdfResult representa una unión discriminada con dos casos: Success y Failure. El caso Success contiene un PdfDocument, mientras que el caso Failure contiene un mensaje de error. El método GeneratePdf toma una cadena HTML, intenta generar un PDF utilizando IronPDF, y devuelve el resultado como un PdfResult. Si la generación del PDF tiene éxito, devuelve el caso Success con el PDF generado. Si ocurre una excepción, devuelve el caso Failure con el mensaje de error.
Las uniones discriminadas en C# proporcionan una manera poderosa y flexible de modelar datos con múltiples posibles casos. Aunque C# no soporta uniones discriminadas, puedes simularlas usando jerarquías de clases, coincidencia de patrones y otras técnicas. El código resultante es más seguro en términos de tipado, menos propenso a errores y más fácil de mantener.
IronPDF proporciona una prueba gratuita para ayudarte a probar el software sin ningún costo inicial. Puedes explorar todas las características y ver cómo se alinean con tus necesidades. Después de tu prueba, las licencias están disponibles a partir de $999.
Jacob Mellor is Chief Technology Officer at Iron Software and a visionary engineer pioneering C# PDF technology. As the original developer behind Iron Software's core codebase, he has shaped the company's product architecture since its inception, transforming it alongside CEO Cameron Rimington into a 50+ person company serving NASA, Tesla, and global government agencies.
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
