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 zu zeigen, wie sie in Ihren C#-Anwendungen effektiv eingesetzt werden können, indem Sie dieIronPDF-Bibliothek für die PDF-Erzeugung in .NET.

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 Schlüsselwort enum 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: Frühling, Sommer, Herbst und Winter. Durch die Definition dieser Aufzählung können wir nun Variablen vom Typ Saison erstellen, die nur einen dieser vier Werte enthalten 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. Damit ist klar, dass currentSeason nur einen Wert enthalten 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 hat autumnInt den Wert 4, was Autumn in der Season Aufzählung entspricht. Umgekehrt wird Saison auf Herbst gesetzt, wenn die ganze Zahl 4 in eine Saison zurückgeführt wird.

Arbeiten mit Enum-Methoden

C# bietet mehrere Methoden für die Arbeit mit Enums, wie Enum.GetName(), Enum.GetNames(), Enum.GetValue(), und Enum.GetValues(), die für den Zugriff auf die mit jedem Enum-Mitglied verbundenen int-Konstanten nützlich 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 Codeschnipsel gibt die Namen aller Mitglieder des Season enum aus. 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 Integer-Werten, die jedem Mitglied zugewiesen werden. Dies ist nützlich für vordefinierte numerische Codes, wie z. B. HTTP-Statuscodes.

Verwendung von Enums als Bit-Flags

Durch die Verwendung des [Flaggen]-Attribut können Sie ein Enum als einen Satz 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 OR-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 von Read und Write Berechtigungen.

Enum- und Switch-Anweisungen

Enums funktionieren besonders gut mit switch-Anweisungen, die es Ihnen ermöglichen, verschiedene Codeblöcke auf der Grundlage des Enum-Wertes auszuführen.

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 druckt "Es ist Sommer.", weil die Variable Saison auf Saison.Sommer gesetzt ist.

Parsing String zu Enum

In C# können Sie eine Zeichenkette analysieren, um den entsprechenden Enum-Wert zu erhalten, indem Sie die Funktion Enum.Parse() Methode.

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 die Zeichenfolge "Winter " in den entsprechenden Enum-Wert Season.Winter um.

Integration von IronPDF mit Enums in C#;

IronPDF PDF-Bibliothek für dynamische Dokumentenerzeugung ist eine PDF-Bibliothek für .NET-Anwendungen, mit der Entwickler PDF-Dokumente problemlos erstellen, bearbeiten und manipulieren können. 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 erfahren Sie, wie Sie IronPDF mit C#-Enums integrieren können, umerstellung von PDF-Berichten aus HTML in .NETund wir werden auch 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 zum KonvertierenHTML zu PDF? 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 erhält. Es verwendet die Klasse ChromePdfRenderer von IronPDF, um aus einem HTML-String, der den Namen der Saison und einen Platzhaltertext für die Verkaufsdaten enthält, ein PDF zu erzeugen. Die PDF-Datei wird dann unter einem Dateinamen gespeichert, der den Namen der Saison enthält.

Ausführung

Um einen saisonalen Umsatzbericht zu erstellen, rufen Sie die Methode GenerateSeasonalSalesReport 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 erzeugt ein PDF-Dokument mit dem Namen WinterSalesReport.pdf, das den Umsatzbericht 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 Erzeugung von PDF-Dokumenten auf der Basis von Aufzählungstypen. IronPDF bietet einekostenlose Testversion der umfassenden PDF-Toolsder Text muss eine Reihe von Optionen bieten, um verschiedenen Projektanforderungen und -größen gerecht zu werden.