Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. Unia Rozróżniona C#
POMOC .NET

C# Unie dyskryminacyjne (Jak to dziala dla programistow)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

Unie dyskryminowane, znane również jako unie tagowane lub sumaryczne, są potężnym narzędziem do modelowania danych, które mogą przyjmować różne formy, ale z dobrze zdefiniowanymi i ograniczonymi możliwymi przypadkami. Chociaż C# nie posiada natywnych unii dyskryminowanych, jak niektóre inne języki (np. F# lub Rust), można symulować unie dyskryminowane przy użyciu kilku technik w tym języku. W tym poradniku zgłębimy unie dyskryminowane, jak je zaimplementować w C#, oraz ich praktyczne zastosowanie z biblioteka IronPDF.

Co to jest unia dyskryminowana?

W prostych słowach, unia dyskryminowana to typ, który może przechowywać jedną z kilku z góry określonych form lub wartości. Zapewnia sposób na stworzenie bezpiecznej pod względem typów struktury, która kapsułuje różne typy lub wartości, zapewniając jednocześnie, że tylko prawidłowe przypadki są obsługiwane na etapie kompilacji.

Wyobraź sobie scenariusz, w którym chcesz przedstawić wynik operacji. Operacja może zakończyć się sukcesem, zwracając dane, lub zakończyć się niepowodzeniem, zwracając komunikat o błędzie. Unia dyskryminowana pozwoliłaby ci przedstawić te dwa możliwe wyniki w jednym typie.

Przykład: Symulowanie unii dyskryminowanej w języku C

Oto przykład, jak można symulować unię dyskryminowaną w C# przy użyciu struktury klasowej:

// 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);
}
// 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);
}
Imports System

' Define an abstract base class representing the operation result.
Public MustInherit Class OperationResult(Of T)
    ' Private constructor to ensure the class cannot be instantiated directly.
    Private Sub New()
    End Sub

    ' Nested class representing a successful operation result.
    Public NotInheritable Class Success
        Inherits OperationResult(Of T)

        Public ReadOnly Property Value As T

        Public Sub New(value As T)
            Me.Value = value
        End Sub

        Public Overrides Function ToString() As String
            Return $"Success: {Value}"
        End Function
    End Class

    ' Nested class representing a failed operation result.
    Public NotInheritable Class Failure
        Inherits OperationResult(Of T)

        Public ReadOnly Property Error As String

        Public Sub New([error] As String)
            Me.Error = [error]
        End Sub

        Public Overrides Function ToString() As String
            Return $"Failure: {Error}"
        End Function
    End Class

    ' Factory method to create a successful operation result.
    Public Shared Function CreateSuccess(value As T) As OperationResult(Of T)
        Return New Success(value)
    End Function

    ' Factory method to create a failed operation result.
    Public Shared Function CreateFailure([error] As String) As OperationResult(Of T)
        Return New Failure([error])
    End Function
End Class
$vbLabelText   $csharpLabel

W tym przykładzie OperationResult<t> jest klasą abstrakcyjną, która reprezentuje nasz typ unii dyskryminowanej. Może to być Success z wartością typu T lub Failure z komunikatem o błędzie. Prywatny konstruktor zapewnia, że instancje takiej klasy mogą być tworzone tylko poprzez z góry określone przypadki.

Użycie dopasowywania wzorców z uniami dyskryminowanymi

C# zapewnia potężne możliwości dopasowywania wzorców, które dobrze współpracują z uniami dyskryminowanymi. Rozszerzmy nasz przykład OperationResult<t> o metodę, która obsługuje różne przypadki przy użyciu wyrażenia 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.
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")
'	};
$vbLabelText   $csharpLabel

Wyrażenie switch tutaj obsługuje zarówno przypadki Success, jak i Failure z OperationResult<int>. To zapewnia, że wszystkie możliwe przypadki są obsługiwane na etapie kompilacji, zapewniając bezpieczeństwo typów i zmniejszając ryzyko błędów w czasie wykonania.

Metody rozszerzające dla unii dyskryminowanych

Możesz rozszerzyć funkcjonalność unii dyskryminowanych przy użyciu metod rozszerzających. Na przykład, stwórzmy metodę rozszerzającą dla naszego OperationResult<t>, aby określić, czy wynik jest sukcesem:

// 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<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 Module
$vbLabelText   $csharpLabel

Ta metoda statyczna sprawdza, czy wynik jest instancją przypadku Success.

Natywne wsparcie dla unii dyskryminowanych w języku C

C# nie posiada natywnego wsparcia dla unii dyskryminowanych, jak niektóre inne języki, ale w społeczności trwają dyskusje na temat dodania takiej funkcji. Natywne unie dyskryminowane ułatwiłyby definiowanie i pracę z typami unii bez konieczności polegania na hierarchiach klas.

Błędy kompilatora i bezpieczeństwo typów

Jedną z kluczowych zalet unii dyskryminowanych jest bezpieczeństwo typów, które zapewniają. Ponieważ wszystkie możliwe przypadki są znane na etapie kompilacji, kompilator może wymusić, że wszystkie przypadki są obsługiwane. To prowadzi do mniejszej liczby błędów w czasie wykonania i czyni kod mniej podatnym na błędy.

Na przykład, jeśli zapomnisz obsłużyć konkretny przypadek w instrukcji switch, kompilator wygeneruje błąd, nakłaniając cię do obsługi brakującego przypadku. Jest to szczególnie przydatne przy pracy ze złożonymi strukturami danych z wieloma możliwymi przypadkami.

Użycie IronPDF z uniami dyskryminowanymi w języku C

Unia dyskryminowana w C# (Jak to działa dla programistów): Rysunek 1 - IronPDF

IronPDF to biblioteka PDF dla C#, która pomaga programistom tworzyć pliki PDF z HTML i umożliwia im modyfikowanie plików PDF bez problemu. Podczas pracy z plikami PDF w C#, możesz zintegrować IronPDF z uniami dyskryminowanymi, aby obsłużyć różne scenariusze przy generowaniu lub przetwarzaniu plików PDF. Na przykład, możesz mieć proces, który albo z powodzeniem generuje plik PDF, albo napotyka błąd. Unie dyskryminowane pozwalają jasno modelować ten proces. Stwórzmy prosty przykład, w którym generujemy plik PDF przy użyciu IronPDF i zwracamy wynik jako unię dyskryminowaną.

// 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.
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(ByVal 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(ByVal 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(ByVal pdf As PdfDocument) As PdfResult
		Return New Success(pdf)
	End Function

	' Factory method to create a failed PDF result.
	Public Shared Function CreateFailure(ByVal 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(ByVal 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 Class
$vbLabelText   $csharpLabel

Klasa PdfResult reprezentuje unię dyskryminowaną z dwoma przypadkami: Success i Failure. Przypadek Success zawiera PdfDocument, podczas gdy przypadek Failure trzyma komunikat o błędzie. Metoda GeneratePdf przyjmuje ciąg HTML, próbuje wygenerować PDF przy użyciu IronPDF i zwraca wynik jako PdfResult. Jeśli generowanie PDF zakończy się sukcesem, zwraca przypadek Success z wygenerowanym PDF-em. Jeśli wystąpi wyjątek, zwraca przypadek Failure z komunikatem o błędzie.

Wnioski

Unia dyskryminowana w C# (Jak to działa dla programistów): Rysunek 2 - Licencjonowanie

Unie dyskryminowane w C# oferują potężny i elastyczny sposób na modelowanie danych z wieloma możliwymi przypadkami. Chociaż C# nie obsługuje unii dyskryminowanych, możesz je symulować przy użyciu hierarchii klas, dopasowywania wzorców i innych technik. Efekt jest bardziej bezpieczny pod względem typów, mniej podatny na błędy i łatwiejszy w utrzymaniu.

IronPDF oferuje bezpłatną wersję próbną, aby umożliwić ci poznanie oprogramowania bez żadnych kosztów na wstępie. Możesz odkrywać wszystkie funkcje i zobaczyć, jak wpisują się w twoje potrzeby. Po okresie próbnym, licencje są dostępne od $799.

Często Zadawane Pytania

Jak utworzyć zjednoczenie z rozróżnieniem w języku C#?

W języku C# można utworzyć zróżnicowaną unię, definiując klasę abstrakcyjną z zagnieżdżonymi podklasami. Każda podklasa reprezentuje możliwy przypadek, taki jak stan powodzenia lub błędu, a do obsługi tych przypadków można użyć dopasowywania wzorców.

Jaka jest rola biblioteki IronPDF w obsłudze zjednoczeń dyskryminowanych?

Biblioteka IronPDF może być używana wraz z dyskryminowanymi zjednoczeniami do zarządzania wynikami generowania plików PDF. Modelując te wyniki jako dyskryminowane zjednoczenia, można zapewnić bezpieczeństwo typów i obsłużyć zarówno pomyślne utworzenie plików PDF, jak i wszelkie występujące błędy.

W jaki sposób dopasowywanie wzorców usprawnia dyskryminowane unie w języku C#?

Dopasowywanie wzorców ulepsza dyskryminowane unie w języku C#, umożliwiając programistom eleganckie obsłużenie każdego możliwego przypadku. Dzięki dopasowywaniu wzorców można bezpiecznie zarządzać różnymi wynikami, zapewniając uwzględnienie wszystkich scenariuszy w czasie kompilacji.

Dlaczego zjednoczenia dyskryminowane są korzystne dla generowania plików PDF w języku C#?

Związki dyskryminowane są przydatne przy generowaniu plików PDF w języku C#, ponieważ zapewniają uporządkowany sposób obsługi przypadków powodzenia i błędów. Takie podejście gwarantuje, że potencjalne problemy są rozwiązywane w czasie kompilacji, co ogranicza liczbę błędów wykonawczych podczas tworzenia plików PDF.

Czy w języku C# można rozszerzać dyskryminowane unie o dodatkowe funkcje?

Tak, zjednoczenia dyskryminowane można rozszerzyć o dodatkowe funkcje za pomocą metod rozszerzeń. Pozwala to na dodanie niestandardowych zachowań, takich jak sprawdzanie statusu powodzenia generowania pliku PDF, bez zmiany podstawowej struktury.

Czy istnieje sposób na symulację zjednoczeń dyskryminowanych w języku C# bez natywnej obsługi?

Tak, mimo że język C# nie obsługuje natywnie unii rozróżnianych, można je symulować za pomocą hierarchii klas. Abstrakcyjna klasa bazowa może być używana z klasami zagnieżdżonymi do reprezentowania różnych możliwych wyników, takich jak przypadki powodzenia lub niepowodzenia.

W jaki sposób programiści C# mogą skutecznie obsługiwać błędy podczas generowania PDF?

Programiści C# mogą skutecznie obsługiwać błędy podczas generowania PDF, stosując unie rozróżnione do modelowania potencjalnych wyników. To podejście zapewnia, że błędy są adresowane na etapie kompilacji, co poprawia niezawodność i łatwość utrzymania kodu.

Jakie są zalety korzystania z IronPDF z uniami rozróżnionymi w projektach C#?

Korzystanie z IronPDF z uniami rozróżnionymi w projektach C# oferuje zaletę solidnej obsługi błędów podczas generowania PDF. Ta kombinacja pozwala na jasne rozróżnienie między udanymi operacjami a błędami, zwiększając bezpieczeństwo i niezawodność kodu.

W jaki sposób unie rozróżnione przyczyniają się do bezpieczeństwa typów w C#?

Unie rozróżnione przyczyniają się do bezpieczeństwa typów w C# poprzez zapewnienie, że wszystkie potencjalne przypadki są obsługiwane podczas kompilacji. Zmniejsza to prawdopodobieństwo wystąpienia błędów czasu wykonania i sprawia, że kod jest bardziej przewidywalny i łatwiejszy w utrzymaniu.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie