C# Enums (Wie es für Entwickler funktioniert)

Enums, die Abkürzung für Aufzählungen, sind eine leistungsstarke Funktion, die es Entwicklern ermöglicht, eine Reihe von benannten Konstanten zu erstellen. Diese Konstanten machen den Code lesbarer und wartungsfreundlicher, indem sie sinnvolle Namen für Werte bereitstellen. In diesem Artikel werden wir die Grundlagen und fortgeschrittenen Konzepte von Enums in C# anhand verschiedener Beispiele und Erklärungen untersuchen. Unser Ziel ist es, ein umfassendes Verständnis von Enums zu vermitteln und wie sie effektiv in Ihren C#-Anwendungen mithilfe der IronPDF-Bibliothek zur PDF-Erstellung in .NET genutzt werden können.

Einführung in Enum in C##

Ein Enum ist ein Wertetyp in C#, der es einer Variablen ermöglicht, eine Reihe von vordefinierten Konstanten zu sein, die jeweils als Enum-Mitglied bezeichnet werden. Das enum-Schlüsselwort wird verwendet, um einen Aufzählungstyp zu deklarieren, der eine Möglichkeit bietet, konstante Werte unter einem einzigen Namen zu gruppieren. Enums verbessern die Lesbarkeit des Codes und reduzieren Fehler, die durch die Übergabe falscher Werte entstehen.

enum Season { Spring, Summer, Autumn, Winter }

enum Season { Spring, Summer, Autumn, Winter }

Friend Enum Season
	Spring
	Summer
	Autumn
	Winter
End Enum

Im obigen Code ist Season ein Enum-Typ mit vier Mitgliedern: Spring, Summer, Autumn und Winter. Durch die Definition dieses Enums können wir nun Variablen vom Typ Season erstellen, die nur einen dieser vier Werte halten können.

Zugrunde liegender Typ von Enums

Den Integer-Wert von Enum-Mitgliedern verstehen

Standardmäßig ist der zugrundeliegende Typ einer enum in C# int, der zugrundeliegende Integraltyp, und die Integer-Werte der enum-Mitglieder beginnen bei 0. Der Integer-Wert jedes Mitglieds wird vom vorherigen Mitglied um 1 erhöht, sofern nicht ausdrücklich angegeben. Der zugrundeliegende Typ einer Aufzählung kann auch als ein beliebiger anderer ganzzahliger Typ definiert werden.

enum Season : byte { Spring = 1, Summer, Autumn = 4, Winter }

enum Season : byte { Spring = 1, Summer, Autumn = 4, Winter }

Friend Enum Season As Byte
	Spring = 1
	Summer
	Autumn = 4
	Winter
End Enum

In diesem Beispiel ist Season ein Enum, hier als Enum-Name bezeichnet, mit einem Byte als zugrunde liegendem Typ. Dem Frühling wird ausdrücklich der Wert 1 zugewiesen, was ihn zum Standardwert macht, während Sommer, Herbst und Winter je nach ihrer Reihenfolge entsprechende Werte zugewiesen werden.

Verwendung von Enums in Ihrem Code

Um eine Aufzählung zu verwenden, deklarieren Sie einfach eine Variable des angegebenen Aufzählungstyps und weisen ihr einen Wert einer Aufzählung zu, z. B. einen der verschiedenen Werte, die in der Aufzählungsdeklaration definiert sind, wobei Sie die Punktsyntax verwenden.

Season currentSeason = Season.Autumn;

Season currentSeason = Season.Autumn;

Dim currentSeason As Season = Season.Autumn

Diese Zeile erstellt eine Variable currentSeason vom Typ Season und weist ihr den Wert Autumn zu. Dies macht deutlich, dass currentSeason nur einen Wert halten kann, der eine gültige Season ist.

Konvertierung zwischen Enum-Werten und Ganzzahlen

Sie können einen Aufzählungswert in seinen entsprechenden ganzzahligen Wert umwandeln, indem Sie einen gegebenen ganzzahligen Wert verwenden, und umgekehrt. Dies ist nützlich, wenn Sie Daten in ihrer numerischen Form speichern oder übertragen müssen.

int autumnInt = (int)Season.Autumn;
Season season = (Season)4;

int autumnInt = (int)Season.Autumn;
Season season = (Season)4;

Imports System

Dim autumnInt As Integer = CInt(Math.Truncate(Season.Autumn))
Dim season As Season = CType(4, Season)

Hier wird autumnInt den Wert 4 haben, was Herbst im Season enum entspricht. Umgekehrt wird season auf Autumn gesetzt, wenn die Ganzzahl 4 zurück auf Season umgewandelt wird.

Arbeiten mit Enum-Methoden

C# bietet mehrere Methoden zur Arbeit mit Enums, wie Enum.GetName(), Enum.GetNames(), Enum.GetValue() und Enum.GetValues(), die nützlich sind, um auf die int-Konstanten zuzugreifen, die jedem Enum-Mitglied zugeordnet sind.

string[] names = Enum.GetNames(typeof(Season));
foreach (string name in names)
{
    Console.WriteLine(name);
}

string[] names = Enum.GetNames(typeof(Season));
foreach (string name in names)
{
    Console.WriteLine(name);
}

Dim names() As String = System.Enum.GetNames(GetType(Season))
For Each name As String In names
	Console.WriteLine(name)
Next name

Dieser Codeausschnitt druckt die Namen aller Mitglieder des Season-Enums. Solche Methoden sind äußerst nützlich, um alle möglichen Werte einer Aufzählung zu durchlaufen oder zwischen der String-Darstellung und dem Aufzählungswert zu konvertieren.

Enum-Mitgliedern bestimmte Werte zuweisen

Sie können Enum-Mitgliedern bestimmte Ganzzahlwerte zuweisen, um ihren numerischen Wert explizit zu steuern.

enum ErrorCode : int { None = 0, NotFound = 404, Unauthorized = 401 }

enum ErrorCode : int { None = 0, NotFound = 404, Unauthorized = 401 }

Friend Enum ErrorCode As Integer
	None = 0
	NotFound = 404
	Unauthorized = 401
End Enum

In diesem Beispiel ist ErrorCode ein Enum mit benutzerdefinierten ganzzahligen Werten, die jedem Mitglied zugewiesen sind. Dies ist nützlich für vordefinierte numerische Codes, wie z. B. HTTP-Statuscodes.

Verwendung von Enums als Bit-Flags

Durch die Verwendung des [Flags]-Attributs können Sie ein Enum als eine Menge von Bit-Flags definieren. So können Sie eine Kombination von Werten in einer einzigen Enum-Variablen speichern.

[Flags]
enum Permissions { None = 0, Read = 1, Write = 2, Execute = 4 }

[Flags]
enum Permissions { None = 0, Read = 1, Write = 2, Execute = 4 }

<Flags>
Friend Enum Permissions
	None = 0
	Read = 1
	Write = 2
	Execute = 4
End Enum

Mit dem oben definierten Permissions-Enum können Sie verschiedene Berechtigungen mit dem bitweisen ODER-Operator kombinieren.

Permissions myPermissions = Permissions.Read 
 Permissions.Write;

Permissions myPermissions = Permissions.Read 
 Permissions.Write;

Dim myPermissions As Permissions = Permissions.Read Permissions.Write

Dies setzt myPermissions auf eine Kombination aus Read und Write-Berechtigungen.

Enum- und Switch-Anweisungen

Enums funktionieren hervorragend mit switch-Anweisungen, sodass Sie unterschiedliche Codeblöcke basierend auf dem Wert des Enums ausführen können.

Season season = Season.Summer;
switch (season)
{
    case Season.Spring:
        Console.WriteLine("It's spring.");
        break;
    case Season.Summer:
        Console.WriteLine("It's summer.");
        break;
    case Season.Autumn:
        Console.WriteLine("It's autumn.");
        break;
    case Season.Winter:
        Console.WriteLine("It's winter.");
        break;
}

Season season = Season.Summer;
switch (season)
{
    case Season.Spring:
        Console.WriteLine("It's spring.");
        break;
    case Season.Summer:
        Console.WriteLine("It's summer.");
        break;
    case Season.Autumn:
        Console.WriteLine("It's autumn.");
        break;
    case Season.Winter:
        Console.WriteLine("It's winter.");
        break;
}

Dim season As Season = Season.Summer
Select Case season
	Case Season.Spring
		Console.WriteLine("It's spring.")
	Case Season.Summer
		Console.WriteLine("It's summer.")
	Case Season.Autumn
		Console.WriteLine("It's autumn.")
	Case Season.Winter
		Console.WriteLine("It's winter.")
End Select

Dieser Code wird "Es ist Sommer." ausgeben, weil die season-Variable auf Season.Summer gesetzt ist.

Parsing String zu Enum

C# ermöglicht es Ihnen, einen String zu parsen, um den entsprechenden Enum-Wert mithilfe der Enum.Parse()-Methode zu erhalten.

string input = "Winter";
Season season = (Season)Enum.Parse(typeof(Season), input);

string input = "Winter";
Season season = (Season)Enum.Parse(typeof(Season), input);

Dim input As String = "Winter"
Dim season As Season = DirectCast(System.Enum.Parse(GetType(Season), input), Season)

Dieser Code wandelt den String "Winter" in den entsprechenden Enum-Wert Season.Winter um.

Integration von IronPDF mit Enums in C#;

IronPDF PDF Library for Dynamic Document Generation ist eine PDF-Bibliothek für .NET-Anwendungen, die Entwicklern hilft, PDF-Dokumente einfach zu erstellen, zu bearbeiten und zu manipulieren. Diese leistungsstarke Bibliothek kann besonders in Szenarien nützlich sein, in denen eine dynamische PDF-Erzeugung erforderlich ist, z. B. bei der Erstellung von Berichten oder Rechnungen. In diesem Abschnitt werden wir erkunden, wie man IronPDF mit C#-Enums für die Erstellung von PDF-Berichten aus HTML in .NET integriert. Außerdem werden wir den Installationsprozess von IronPDF in Ihrem Projekt behandeln.

Mit IronPDF können Sie beliebige HTML-, URL- oder Webseiten in eine PDF-Datei umwandeln, die exakt wie die Quelle aussieht. Es ist eine großartige Option zum Erstellen von PDFs für Rechnungen, Berichte und andere webbasierte Inhalte. Bereit, HTML in PDF zu konvertieren? IronPDF macht es mühelos.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Installation von IronPDF

Die Installation von IronPDF ist mit der NuGet-Paketmanager-Konsole sehr einfach. Öffnen Sie die Konsole des Paketmanagers in Visual Studio und geben Sie den folgenden Befehl ein:

Install-Package IronPdf

Mit diesem Befehl wird IronPDF in unserem Projekt installiert.

Eine Alternative ist die Installation von IronPDF in Ihrem Projekt unter Verwendung von Visual Studio. Klicken Sie in Visual Studio mit der rechten Maustaste auf den Projektmappen-Explorer und klicken Sie auf NuGet Package Manager for Solutions. Klicken Sie anschließend auf die Registerkarte Durchsuchen auf der linken Seite. Suchen Sie dann nach IronPDF, klicken Sie auf Installieren und fügen Sie es zu Ihrem Projekt hinzu.

Verwendung von IronPDF mit Enums

Nehmen wir ein Szenario an, in dem Sie ein PDF-Dokument erstellen möchten, das einen Bericht über saisonale Verkaufsdaten enthält. Sie können Enums zur Darstellung verschiedener Jahreszeiten und IronPDF zur Erstellung des PDF-Berichts verwenden. Definieren Sie zunächst ein Enum für die Jahreszeiten:

public enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

public enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Public Enum Season
	Spring
	Summer
	Autumn
	Winter
End Enum

Als Nächstes werden wir eine Methode schreiben, die einen PDF-Bericht auf der Grundlage der ausgewählten Jahreszeit erstellt. Bei dieser Methode wird IronPDF verwendet, um ein einfaches PDF-Dokument zu erstellen, das die Verkaufsdaten für die jeweilige Saison enthält.

using IronPdf;
public class SalesReportGenerator
{
    public static void GenerateSeasonalSalesReport(Season season)
    {
        IronPdf.License.LicenseKey = "License-Key";
        var Renderer = new IronPdf.ChromePdfRenderer();
        var htmlTemplate = $"<h1>Sales Report for {season}</h1><p>This section contains sales data for the {season} season.</p>";
        var pdf = Renderer.RenderHtmlAsPdf(htmlTemplate);
        var outputPath = $@"{season}SalesReport.pdf";
        pdf.SaveAs(outputPath);
        Console.WriteLine($"PDF report generated: {outputPath}");
    }
}

using IronPdf;
public class SalesReportGenerator
{
    public static void GenerateSeasonalSalesReport(Season season)
    {
        IronPdf.License.LicenseKey = "License-Key";
        var Renderer = new IronPdf.ChromePdfRenderer();
        var htmlTemplate = $"<h1>Sales Report for {season}</h1><p>This section contains sales data for the {season} season.</p>";
        var pdf = Renderer.RenderHtmlAsPdf(htmlTemplate);
        var outputPath = $@"{season}SalesReport.pdf";
        pdf.SaveAs(outputPath);
        Console.WriteLine($"PDF report generated: {outputPath}");
    }
}

Imports IronPdf
Public Class SalesReportGenerator
	Public Shared Sub GenerateSeasonalSalesReport(ByVal season As Season)
		IronPdf.License.LicenseKey = "License-Key"
		Dim Renderer = New IronPdf.ChromePdfRenderer()
		Dim htmlTemplate = $"<h1>Sales Report for {season}</h1><p>This section contains sales data for the {season} season.</p>"
		Dim pdf = Renderer.RenderHtmlAsPdf(htmlTemplate)
		Dim outputPath = $"{season}SalesReport.pdf"
		pdf.SaveAs(outputPath)
		Console.WriteLine($"PDF report generated: {outputPath}")
	End Sub
End Class

In diesem Beispiel definieren wir eine Methode GenerateSeasonalSalesReport, die ein Season-Enum als Parameter annimmt. Es verwendet die ChromePdfRenderer-Klasse von IronPDF, um aus einem HTML-String, der den Saisonnamen und einen Platzhaltertext für Verkaufsdaten enthält, ein PDF zu generieren. Die PDF-Datei wird dann unter einem Dateinamen gespeichert, der den Namen der Saison enthält.

Ausführung

Um einen saisonalen Verkaufsbericht zu erstellen, rufen Sie die GenerateSeasonalSalesReport-Methode mit einer bestimmten Saison auf:

static void Main(string [] args)
{
    SalesReportGenerator.GenerateSeasonalSalesReport(Season.Winter);
}

static void Main(string [] args)
{
    SalesReportGenerator.GenerateSeasonalSalesReport(Season.Winter);
}

Shared Sub Main(ByVal args() As String)
	SalesReportGenerator.GenerateSeasonalSalesReport(Season.Winter)
End Sub

Dieser Aufruf generiert ein PDF-Dokument mit dem Namen WinterSalesReport.pdf, das den Verkaufsbericht für die Wintersaison enthält.

Schlussfolgerung

Enums in C# bieten eine typsichere Möglichkeit, mit Gruppen von verwandten benannten Konstanten zu arbeiten. Sie verbessern die Lesbarkeit des Codes, reduzieren Fehler und erleichtern eine saubere Codeorganisation. Durch die Gruppierung verwandter konstanter Werte unter einem aussagekräftigen Namen machen Enums Ihren Code leichter verständlich und wartbar.

Die Integration von IronPDF mit Enums in C# ermöglicht die dynamische Erstellung von PDF-Dokumenten auf Basis von enumerierten Typen. IronPDF bietet eine kostenlose Testversion seiner umfassenden PDF-Tools an und stellt eine Vielzahl von Optionen bereit, um unterschiedliche Projektanforderungen und -größen zu erfüllen.