C# Dyskryminowane unie (Jak to działa dla deweloperów)

Czym są unie wyróżnione w C#?

Unie wyróżnione, znane również jako unie oznaczone lub typy unii, pozwalają zmiennej przechowywać jedną wartość z ograniczonego zestawu możliwych opcji, gdzie każda opcja jest powiązana z unikalnym identyfikatorem przypadku.

W innych językach, takich jak F#, można je zdefiniować za pomocą słowa kluczowego union. C# nie oferuje tej funkcji natywnie, ale programiści mogą zastosować sprytne kombinacje rekordów, klas i wyrażeń switch, aby je naśladować.

Na przykład:

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

Każdy rekord powyżej reprezentuje pojedynczy przypadek unii. Podstawowy typ PdfAction jest wyróżnikiem.

Dlaczego Unie Wyróżnione Są Ważne w Przepływach Pracy w IronPDF

Wyobraź sobie, że tworzysz generator raportów PDF z wykorzystaniem IronPDF i musisz wykonać różne czynności na podstawie danych wejściowych od użytkownika—może generować PDF, rejestrować błędy lub eksportować dane.

Użycie unii wyróżnionych w C# pozwala reprezentować te typy opcji w przejrzysty sposób, prowadząc do bezpieczeństwa w czasie kompilacji, mniejszej liczby błędów i bardziej przejrzystej logiki.

Oto jak możesz to zastosować z 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

To podejście utrzymuje Twój kod w porządku i mocny, a także ułatwia programistom zrozumienie wszystkich możliwych opcji w jednym miejscu.

Symulowanie unii wyróżnionych w C# – struktura vs. rekord vs. klasa

Chociaż C# nie posiada słowa kluczowego union, można symulować unie wyróżnione używając:

• Rekordy: Idealne dla niemutowalnych danych i wspierają czysto dopasowywanie wzorca.
• Klasy: Bardziej elastyczne pod względem dziedziczenia i semantyki referencyjnej.
• Struktury: Przydatne dla typów wartości, ale mniej elastyczne przy pracy z typami referencyjnymi lub dziedziczeniem.

Jeśli zależy Ci na wydajności i usytuowaniu pamięci—na przykład, w logowaniu PDF o dużej przepustowości—możesz rozważyć ostrożne użycie unii wyróżnionych struktur:

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

Uwaga: Stracisz niektóre korzyści z dopasowania wzorców z strukturami, szczególnie polegając na wyrażeniach switch.

Zalety stosowania unii wyróżnionych w C

Istnieje kilka kluczowych zalet przy adopcji tego wzorca inżynierii oprogramowania:

• Bezpieczeństwo w czasie kompilacji: Uchwyt na brakujące przypadki w wyrażeniu switch przed uruchomieniem.
• Bardziej przejrzysta logika: Łatwiej jest pisać, komentować i analizować działania w przypadku oznaczonych nazw.
• Oddzielenie obowiązków: Odpowiedzialności odniesione na danych, a nie hierarchiach typów.
• Łatwość refaktoryzacji: Dodawanie lub usuwanie przypadków staje się bardziej prostoliniowe.

W połączeniu z IronPDF, to ułatwia zarządzanie wejściem użytkownika, logiką renderingu lub tworzenie dynamicznych szablonów z różnymi potokami wartości.

Kiedy Używać Unii Wyróżnionych z IronPDF

Oto kilka praktycznych scenariuszy, w których ten wzorzec doskonale się sprawdza:

• Przepływy pracy generowania PDF: Różne kroki w cyklu życia dokumentu (generowanie, zapisywanie, e-mail).
• Modele uprawnień: Reprezentowanie różnych poziomów dostępu użytkowników.
• Systemy logowania: Użycie typów unii wyróżnionych w przypadku poziomów logowania (informacje, błędy, debugowanie).
• Testy jednostkowe: Definiowanie działań testowych jako typów unii dla drzew logiki, które można utrzymać.
• Opcje eksportu: Reprezentowanie lokalizacji docelowych takich jak PDF, Excel, Word jako instancje unii.

Przykład – Obsługa działań PDF ze zdarzeń UI

Załóżmy, że wychwytujesz zdarzenia UI i chcesz kierować je do zadań IronPDF za pomocą unii wyróżnionych:

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

Pozwala to reprezentować zdarzenia z przejrzystą logiką i zmniejsza zależność od publicznych typów obiektów lub zbyt dynamicznej obsługi.

Perspektywy na przyszłość – czy C# kiedykolwiek będzie obsługiwał natywne unie wyróżnione?

Istnieje już propozycja dodania natywnego wsparcia dla unii wyróżnionych w C#, szczególnie w obliczu rosnącego zapotrzebowania na bardziej ekspresywne systemy typów. Chociaż język nie wprowadził jeszcze prawdziwego słowa kluczowego union, C# nadal się rozwija—przybliżając funkcje takie jak rekordy, dopasowywanie wzorców i wyrażenia switch do pełnej funkcjonalności unii wyróżnionych.

Deweloperzy .NET zainteresowani nowoczesnymi, przyjaznymi dla funkcji konstruktami językowymi powinni uważnie obserwować ten obszar.

Podsumowanie

Użycie unii wyróżnionych w C# nawet bez natywnego wsparcia, może znacząco poprawić strukturę i reprezentację logiki w aplikacjach IronPDF. Wykorzystując rekordy, wyrażenia switch i klasy bazowe, sprawisz, że Twoja baza kodowa będzie bardziej czytelna, łatwiejsza do utrzymania i odporna na błędy—jednocześnie odblokowując bardziej deklaratywny i ekspresyjny sposób obsługi zadań związanych z PDF.

Jeśli jesteś inżynierem oprogramowania tworzącym nowoczesne, elastyczne aplikacje .NET, ten wzorzec musi się znaleźć w twoim narzędziowniku.