C# Uniones Discriminadas (Cómo Funciona para Desarrolladores)

¿Qué son las uniones discriminadas en C#?

Las uniones discriminadas, también conocidas como uniones etiquetadas o tipos de unión, permiten que una variable contenga un valor de un conjunto limitado de opciones posibles, donde cada opción está asociada con un identificador de caso único.

En otros lenguajes como F#, podrías definirlas usando la palabra clave union. C# no proporciona esta característica de manera nativa, pero los desarrolladores pueden usar combinaciones inteligentes de registros, clases y expresiones switch para imitarlas.

Por ejemplo:

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

Cada registro arriba representa un caso único de la unión. El tipo base PdfAction es el discriminante.

Por qué son importantes las uniones discriminadas en los flujos de trabajo de IronPDF

Imagina que estás construyendo un generador de informes PDF utilizando IronPDF, y necesitas realizar diferentes acciones basadas en la entrada de un usuario, tal vez generar un PDF, registrar un error o exportar datos.

El uso de uniones discriminadas en C# te permite representar estos tipos de opciones limpiamente, lo que lleva a una seguridad en tiempo de compilación, menos errores y una lógica más clara.

Aquí te mostramos cómo podrías usarlo con 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

Este enfoque mantiene tu código organizado y robusto, y facilita que los desarrolladores entiendan todas las opciones posibles en una sola ubicación.

Simulación de uniones discriminadas en C# - Struct vs. Record vs. Class

Aunque C# carece de la palabra clave union, puedes simular uniones discriminadas utilizando:

• Registros: Ideales para datos inmutables, y soportan coincidir patrones de manera limpia.
• Clases: Más flexibles con la herencia y semántica de referencia.
• Estructuras: Útiles para tipos de valor, pero menos flexibles al trabajar con tipos de referencia o herencia.

Si el rendimiento y la disposición de memoria son importantes —por ejemplo, en el registro de PDF de alto rendimiento— podrías considerar usar estructuras de uniones discriminadas con cuidado:

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

Nota: Perderás algunos beneficios de coincidencia de patrones con estructuras, especialmente al depender de expresiones switch.

Beneficios del uso de uniones discriminadas en C#

Hay varias ventajas clave al adoptar este patrón de ingeniería de software:

• Seguridad en tiempo de compilación: Detectarás casos faltantes en una expresión switch antes del tiempo de ejecución.
• Lógica más clara: Es más fácil escribir, comentar y razonar sobre acciones con casos nombrados.
• Separación de responsabilidades: Desacoplas comportamientos basados en datos en lugar de jerarquías de tipos.
• Facilidad de refactorización: Agregar o eliminar casos se vuelve más sencillo.

Al combinarlo con IronPDF, esto facilita la gestión de la entrada del usuario, la lógica de renderización o crear plantillas dinámicas con diferentes conductos de valor.

Cuándo utilizar uniones discriminadas con IronPDF

Aquí hay algunos escenarios prácticos donde este patrón sobresale:

• Flujos de Trabajo de Generación de PDF: Diferentes pasos en el ciclo de vida de un documento (generar, guardar, enviar por correo electrónico).
• Modelos de Permisos: Representar diferentes niveles de acceso del usuario.
• Sistemas de Registro: Usar tipos de uniones discriminadas para niveles de registro (información, error, depuración).
• Pruebas Unitarias: Definir acciones de prueba como tipos de unión para árboles lógicos mantenibles.
• Opciones de Exportación: Representar objetivos de salida como PDF, Excel, Word como instancias de unión.

Ejemplo - Manejo de acciones PDF a partir de eventos de interfaz de usuario

Supongamos que estás capturando eventos de interfaz de usuario y quieres encaminarlos a tareas de IronPDF usando uniones discriminadas:

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;
'	}
'}

Esto te permite representar eventos con una lógica clara y reduce la dependencia de tipos de objetos públicos o de manejo excesivamente dinámico.

Perspectivas de futuro - ¿Soportará algún día C&num las uniones discriminadas nativas?

Ya se ha propuesto agregar soporte nativo para uniones discriminadas en C#, especialmente con la creciente demanda de sistemas de tipos más expresivos. Aunque el lenguaje aún no ha introducido una verdadera palabra clave de unión, C# sigue evolucionando, introduciendo características como registros, coincidencia de patrones y expresiones switch más cercanas a la funcionalidad completa de uniones discriminadas.

Los desarrolladores .NET interesados en constructos de lenguaje modernos y amigables para la programación funcional querrán seguir de cerca este espacio.

Reflexiones finales

El uso de uniones discriminadas en C#, incluso sin soporte nativo, puede mejorar significativamente la forma en que estructuras y representas la lógica en aplicaciones de IronPDF. Al aprovechar los registros, expresiones switch y clases base, harás que tu base de código sea más legible, mantenible y resistente a errores, al tiempo que desbloquea una forma más declarativa y expresiva de manejar tareas relacionadas con PDF.

Si eres un ingeniero de software construyendo aplicaciones .NET modernas y flexibles, este patrón es indispensable en tu conjunto de herramientas.