C# Diskriminierte Vereinigungen (Wie es für Entwickler funktioniert)

Was sind diskriminierte Unions in C&num?

Diskriminierte Unions, auch bekannt als markierte Unions oder Vereinigungstypen, ermöglichen es einer Variablen, einen Wert aus einer begrenzten Menge möglicher Optionen zu halten, wobei jede Option mit einem eindeutigen Fallbezeichner verbunden ist.

In anderen Sprachen wie F# könnte man sie mit dem Schlüsselwort union definieren. C# bietet dieses Feature nicht nativ, aber Entwickler können clevere Kombinationen aus Datensätzen, Klassen und Switch-Ausdrücken verwenden, um sie zu simulieren.

Zum Beispiel:

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

Jeder oben gezeigte Datensatz stellt einen einzelnen Fall der Union dar. Der Basis-Typ PdfAction ist der Diskriminator.

Warum diskriminierte Unions in IronPDF-Workflows wichtig sind

Stellen Sie sich vor, Sie erstellen einen PDF-Berichtgenerator mit IronPDF und müssen basierend auf den Eingaben eines Benutzers verschiedene Aktionen ausführen – vielleicht ein PDF generieren, einen Fehler protokollieren oder Daten exportieren.

Die Verwendung von diskriminierten Unions in C# ermöglicht es Ihnen, diese Optionstypen übersichtlich darzustellen, was zu Sicherheit zur Kompilierzeit, weniger Fehlern und klarerer Logik führt.

So verwenden Sie es mit 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

Dieser Ansatz hält Ihren Code organisiert und robust und macht es Entwicklern einfacher, alle möglichen Optionen an einem Ort zu verstehen.

Simulieren von diskriminierten Unions in C# - Struct vs. Record vs. Class

Obwohl C# das union-Schlüsselwort fehlt, können Sie diskriminierte Unions simulieren, indem Sie verwenden:

• Records: Ideal für unveränderliche Daten und unterstützt Pattern Matching auf saubere Weise.
• Klassen: Mehr Flexibilität bei Vererbung und Referenzsemantik.
• Strukturen: Nützlich für Werttypen, aber weniger flexibel bei Referenztypen oder Vererbung.

Wenn Leistung und Speicherauslegung wichtig sind – z. B. bei Hochgeschwindigkeits-PDF-Protokollierung – könnten Sie in Erwägung ziehen, diskriminierte Unionen mit Bedacht zu verwenden:

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

Hinweis: Sie verlieren einige Pattern-Matching-Vorteile mit Strukturen, insbesondere wenn Sie auf Switch-Ausdrücke angewiesen sind.

Vorteile der Verwendung von Discriminated Unions in C

Es gibt mehrere entscheidende Vorteile bei der Annahme dieses Softwareentwicklungs-Musters:

• Kompilierzeitsicherheit: Fehlende Fälle in einem Switch-Ausdruck werden vor der Laufzeit abgefangen.
• Klarere Logik: Aktionen lassen sich mit benannten Fällen leichter schreiben, kommentieren und begründen.
• Trennung der Belange: Sie entkoppeln Verhaltensweisen auf Basis von Daten anstatt von Typhierarchien.
• Einfaches Refactoring: Das Hinzufügen oder Entfernen von Fällen wird unkomplizierter.

In Verbindung mit IronPDF erleichtert dies die Verwaltung von Benutzereingaben, Rendering-Logik oder das Erstellen dynamischer Vorlagen mit unterschiedlichen Wertpipelines.

Wann sollten diskriminierte Unions mit IronPDF verwendet werden

Hier sind einige praktische Szenarien, in denen dieses Muster hervorragend funktioniert:

• PDF-Generierungs-Workflows: Verschiedene Schritte im Lebenszyklus eines Dokuments (generieren, speichern, per E-Mail versenden).
• Berechtigungsmodelle: Stellen unterschiedliche Benutzerzugriffsebenen dar.
• Protokollierungssysteme: Verwenden Sie diskriminierte Union-Typen für Protokollierungsstufen (info, error, debug).
• Unit-Tests: Testaktionen als Union-Typen definieren, um wartungsfreundliche Logikbäume zu schaffen.
• Exportoptionen: Ausgabeziele wie PDF, Excel, Word als Vereinigungsinstanzen darstellen.

Beispiel - Handhabung von PDF-Aktionen aus UI-Events

Angenommen, Sie erfassen UI-Ereignisse und möchten sie mit diskriminierten Unions an IronPDF-Aufgaben weiterleiten:

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

Dies ermöglicht es Ihnen, Ereignisse mit klarer Logik darzustellen und die Abhängigkeit von öffentlichen Objekttypen oder übermäßig dynamischem Handling zu verringern.

Zukunftsausblick - Wird C# jemals native diskriminierte Unions unterstützen?

Es gab bereits einen Vorschlag, native Unterstützung für diskriminierte Unions in C# hinzuzufügen, insbesondere mit der wachsenden Nachfrage nach ausdrucksstärkeren Typsystemen. Während die Sprache noch kein echtes union-Schlüsselwort eingeführt hat, entwickelt sich C# kontinuierlich weiter – indem es Funktionen wie Datensätze, Pattern Matching und Switch-Ausdrücke näher an die volle Funktionalität von diskriminierten Unions bringt.

.NET-Entwickler, die an modernen, funktional-freundlichen Sprachkonstrukten interessiert sind, sollten dieses Thema genau im Auge behalten.

Abschließende Gedanken

Die Verwendung von diskriminierten Unions in C#, auch ohne native Unterstützung, kann erheblich verbessern, wie Sie Logik in IronPDF-Anwendungen strukturieren und darstellen. Durch die Nutzung von Datensätzen, Switch-Ausdrücken und Basisklassen machen Sie Ihren Code lesbarer, wartbarer und widerstandsfähiger gegenüber Fehlern – und gleichzeitig einen deklarativeren und ausdrucksvolleren Umgang mit PDF-bezogenen Aufgaben ermöglichen.

Wenn Sie ein Softwareentwickler sind, der moderne, flexible .NET-Anwendungen erstellt, ist dieses Muster ein unverzichtbares Werkzeug in Ihrem Toolkit.