Jako programista .NET pracujacy z dynamicznym generowaniem PDF za pomoca IronPDF, często potrzebujesz reprezentowac i zarządzać różnymi typami—pomyśl o różnych rodzajach danych dokumentu, komunikatach logow, rolach użytkowników lub opcjach eksportu. To tutaj pojawia sie pojecie unii wyróznionej w C#.

Chociaż C# nie ma natywnego wsparcia dla unii wyróżnionych tak, jak F# czy Rust, nadal możesz skutecznie je symulowac. W tym wpisie na blogu zglebimy jak zdefiniowac i używać typu unii wyróżnionej w C#, pokażemy, jak zastosować go z IronPDF do przetwarzania PDF w rzeczywistych sytuacjach i zbadamy korzysci, jakie ten wzorzec zapewnia—szczegółnie w połączeniu z dopasowaniem wzorca.

What Are Discriminated Unions in C#?

Unie wyróżnione, znane również jako unie oznaczone lub typy unii, pozwalają zmiennej przechowywać jedną wartosc z ograniczonego zestawu możliwych opcji, gdzie kazda opcja jest powiazana z unikalnym identyfikatorem przypadku.

W innych językach, takich jak F#, można je zdefiniowac za pomoca slowa kluczowego union. C# nie oferuje tej funkcji natywnie, ale programisci 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

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

Wyobraz sobie, że tworzysz generator raportów PDF z wykorzystaniem IronPDF i musisz wykonac różne czynnosci na podstawie danych wejsciowych od użytkownika—może generować PDF, rejestrowac błędy lub eksportowac dane.

Uzycie unii rozroznialnych w C# pozwala na czyste reprezentowanie tych typow opcji, co prowadzi do bezpieczenstwa w czasie kompilacji, mniejszej liczby bledow i wyrazniejszej 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

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 Twoj kod w ulekladzie i mocny, a także ułatwia programistom zrozumienie wszystkich możliwych opcji w jednym miejscu.

Simulating Discriminated Unions in C# – Struct vs. Record vs. Class

Chociaż C# nie posiada słowa kluczowego union, można symulowac 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 typow wartosci, ale mniej elastyczne przy pracy z typami referencyjnymi lub dziedziczeniem.

Jeśli zalezy Ci na wydajności i usytuowaniu pamięci—for instance, w logowaniu PDF o duzej przepustowosci—możesz rozwazyc 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

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 niektore korzyści z dopasowania wzorcow z strukturami, szczególnie polegając na wyrażeniach switch.

Benefits of Using Discriminated Unions in C#

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

• Bezpieczenstwo w czasie kompilacji: Uchwyt na brakujące przypadki w wyrazeniu switch przed uruchomieniem.
• Bardziej przejrzysta logika: Łatwiej jest pisać, komentować i analizować działania w przypadku oznaczonych nazw.
• Oddzielenie obowiazkow: Odpowiedzialnosci odniesione na danych, a nie hierarchiach typow.
• Łatwosc refaktoryzacji: Dodawanie lub usuwanie przypadkow staje się bardziej prostoliniowe.

W połączeniu z IronPDF, to ułatwia zarządzanie wejsciem użytkownika, logiką renderingu lub tworzenie dynamicznych szablonow 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 zycia dokumentu (generowanie, zapisywanie, e-mail).
• Modele uprawnien: Reprezentowanie różnych poziomów dostępu użytkowników.
• Systemy logowania: Uzycie typow unii wyróznionych 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 utrzymac.
• Opcje eksportu: Reprezentowanie lokalizacji docelowych takich jak PDF, Excel, Word jako instancje unii.

Przykład – Obsluga Działan PDF z Zdarzeń UI

Załóżmy, że wychwytujesz zdarzenia UI i chcesz kierowac je do zadań IronPDF za pomoca 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;
'	}
'}

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ą logika i zmniejsza zależność od publicznych typow obiektow lub zbyt dynamicznej obsługi.

Future Outlook – Will C# Ever Support Native Discriminated Unions?

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 wprowadzil jeszcze prawdziwego slowa 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ęzykówymi powinni uwaznie obserwowac ten obszar.

Podsumowanie

Użycie unii wyróżnionych w C# nawet bez natywnego wsparcia, może znacząco poprawić strukture i reprezentacje logiki w aplikacjach IronPDF. Wykorzystując rekordy, wyrazenia switch i klasy bazowe, sprawisz, że Twoja baza kodowa będzie bardziej czytelna, łatwiejsza do utrzymania i odporna na błedy—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źc w twoim narzędziowniku.

Wypróbuj za darmo dzisiaj

Gotowy, aby przeniesc swoje generowanie PDF w C# na kolejny poziom? Pobierz IronPDF i zacznij korzystać z bezpłatnej wersji próbnej. Niezaleznie od tego, czy generujesz dokumenty z HTML, logujesz eksporty, czy automatyzujesz raporty korzystając z unii wyróznionych—IronPDF daje Ci moc i wydajność, na ktore Twoja aplikacja zasluguje.