Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Enums
.NET HILFE

C# Enums (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Hauptinhalt: Enums, kurz für Enumerationen, sind eine leistungsstarke Funktion, die es Entwicklern ermöglicht, eine Menge benannter Konstanzen zu etablieren. Diese Konstanten machen den Code lesbarer und wartbarer, indem sie bedeutungsvolle Namen für Werte bereitstellen. In diesem Artikel werden wir die Grundlagen und fortgeschrittenen Konzepte von Enums in C# durch verschiedene Beispiele und Erklärungen erkunden. Unser Ziel ist es, ein umfassendes Verständnis von Enums zu vermitteln und wie sie effektiv in Ihren C#-Anwendungen eingesetzt werden können unter Verwendung der IronPDF-Bibliothek zur PDF-Erstellung in .NET.

Einführung in Enum in C

Ein Enum ist ein Werttyp in C#, der es einer Variablen ermöglicht, eine Menge vordefinierter Konstanten zu sein, die jeweils als Enum-Mitglied bezeichnet werden. Das enum-Schlüsselwort wird verwendet, um einen Enumerationstyp 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 das Übergeben falscher Werte verursacht werden.

// Define an enum with four members
enum Season { Spring, Summer, Autumn, Winter }
// Define an enum with four members
enum Season { Spring, Summer, Autumn, Winter }
' Define an enum with four members
Friend Enum Season
	Spring
	Summer
	Autumn
	Winter
End Enum
$vbLabelText   $csharpLabel

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 des Typs Season erstellen, die nur einen dieser vier Werte halten können.

Unterliegender Typ von Enums

Verständnis des Integer-Wertes von Enum-Mitgliedern

Standardmäßig ist der zugrunde liegende Typ eines Enums in C# int, bekannt als der zugrunde liegende Ganzzahltyp, und die Ganzzahlwerte der Enum-Mitglieder beginnen bei 0. Der Ganzzahlwert jedes Mitglieds wird um 1 vom vorherigen Mitglied erhöht, sofern nicht explizit angegeben. Sie können auch den zugrunde liegenden Typ eines Enums auf einen anderen Ganzzahltyp definieren.

// Define an enum with a byte underlying type and specific values
enum Season : byte { Spring = 1, Summer, Autumn = 4, Winter }
// Define an enum with a byte underlying type and specific values
enum Season : byte { Spring = 1, Summer, Autumn = 4, Winter }
' Define an enum with a byte underlying type and specific values
Friend Enum Season As Byte
	Spring = 1
	Summer
	Autumn = 4
	Winter
End Enum
$vbLabelText   $csharpLabel

In diesem Beispiel hat das Season-Enum ein Byte als zugrunde liegenden Typ. Spring wird explizit ein Wert von 1 zugewiesen, wodurch es zum Standardwert wird, während Summer, Autumn und Winter entsprechende Werte basierend auf ihrer Reihenfolge zugewiesen werden.

Verwendung von Enums in Ihrem Code

Um ein Enum zu verwenden, deklarieren Sie einfach eine Variable des angegebenen Enum-Typs und weisen ihr einen Wert des Enums zu, wie einer der verschiedenen Werte, die innerhalb der Enum-Deklaration definiert sind, unter Verwendung der Punkt-Syntax.

// Declare a Season variable and assign it an enum member value
Season currentSeason = Season.Autumn;
// Declare a Season variable and assign it an enum member value
Season currentSeason = Season.Autumn;
' Declare a Season variable and assign it an enum member value
Dim currentSeason As Season = Season.Autumn
$vbLabelText   $csharpLabel

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 ein gültiger Season ist.

Umwandlung zwischen Enum-Werten und Ganzzahlen

Sie können einen Enum-Wert durch Casting in seinen entsprechenden Ganzzahlwert konvertieren und umgekehrt. Dies ist nützlich, wenn Sie Daten in ihrer numerischen Form speichern oder übertragen müssen.

// Convert Season.Autumn to its integer value and vice versa
int autumnInt = (int)Season.Autumn;     // autumnInt will be 4
Season season = (Season)4;              // season will be Season.Autumn
// Convert Season.Autumn to its integer value and vice versa
int autumnInt = (int)Season.Autumn;     // autumnInt will be 4
Season season = (Season)4;              // season will be Season.Autumn
Imports System

' Convert Season.Autumn to its integer value and vice versa
Dim autumnInt As Integer = CInt(Math.Truncate(Season.Autumn)) ' autumnInt will be 4
Dim season As Season = CType(4, Season) ' season will be Season.Autumn
$vbLabelText   $csharpLabel

Hier wird autumnInt den Wert 4 haben, der Autumn im Season-Enum entspricht. Umgekehrt wird season auf Autumn gesetzt, wenn die Ganzzahl 4 zurück auf eine Season gecastet wird.

Arbeiten mit Enum-Methoden

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

// Get names of all enum members and print them
string[] names = Enum.GetNames(typeof(Season));
foreach (string name in names)
{
    Console.WriteLine(name);
}
// Get names of all enum members and print them
string[] names = Enum.GetNames(typeof(Season));
foreach (string name in names)
{
    Console.WriteLine(name);
}
' Get names of all enum members and print them
Dim names() As String = System.Enum.GetNames(GetType(Season))
For Each name As String In names
	Console.WriteLine(name)
Next name
$vbLabelText   $csharpLabel

C#-Enumerationen (So funktioniert es für Entwickler): Abbildung 1 - Konsolenausgabe der einzelnen Werte, die der Season-Enumeration zugeordnet sind

Dieses Code-Snippet druckt die Namen aller Mitglieder des Season-Enums. Solche Methoden sind unglaublich nützlich, um über alle möglichen Werte eines Enums zu iterieren oder zwischen der String-Repräsentation und dem Enum-Wert zu konvertieren.

Enum-Mitgliedern bestimmte Werte zuweisen

Sie können spezifische Ganzzahlwerte für Enum-Mitglieder zuweisen, um ihren numerischen Wert explizit zu steuern.

// Define an enum with custom integer values for members
enum ErrorCode : int { None = 0, NotFound = 404, Unauthorized = 401 }
// Define an enum with custom integer values for members
enum ErrorCode : int { None = 0, NotFound = 404, Unauthorized = 401 }
' Define an enum with custom integer values for members
Friend Enum ErrorCode As Integer
	None = 0
	NotFound = 404
	Unauthorized = 401
End Enum
$vbLabelText   $csharpLabel

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

Verwendung von Enums als Bit-Flags

Indem Sie das [Flags]-Attribut verwenden, können Sie ein Enum als eine Menge von Bit-Flags definieren. Dies ermöglicht es Ihnen, eine Kombination von Werten in einer einzelnen Enum-Variable zu speichern.

[Flags]
// Define an enum for permissions using bit flags
enum Permissions { None = 0, Read = 1, Write = 2, Execute = 4 }
[Flags]
// Define an enum for permissions using bit flags
enum Permissions { None = 0, Read = 1, Write = 2, Execute = 4 }
' Define an enum for permissions using bit flags
<Flags>
Friend Enum Permissions
	None = 0
	Read = 1
	Write = 2
	Execute = 4
End Enum
$vbLabelText   $csharpLabel

Mit dem oben definierten Permissions-Enum können Sie unterschiedliche Berechtigungen mithilfe des bitweisen OR-Operators kombinieren.

// Combine permissions using bitwise OR
Permissions myPermissions = Permissions.Read | Permissions.Write;
// Combine permissions using bitwise OR
Permissions myPermissions = Permissions.Read | Permissions.Write;
' Combine permissions using bitwise OR
Dim myPermissions As Permissions = Permissions.Read Or Permissions.Write
$vbLabelText   $csharpLabel

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

Enum und Switch-Anweisungen

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

// Use a switch statement with an enum
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;
}
// Use a switch statement with an enum
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;
}
' Use a switch statement with an enum
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
$vbLabelText   $csharpLabel

Dieser Code wird "It's summer." drucken, 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 zu erhalten, indem die Enum.Parse()-Methode verwendet wird.

// Parse a string into an enum value
string input = "Winter";
Season season = (Season)Enum.Parse(typeof(Season), input);
// Parse a string into an enum value
string input = "Winter";
Season season = (Season)Enum.Parse(typeof(Season), input);
' Parse a string into an enum value
Dim input As String = "Winter"
Dim season As Season = DirectCast(System.Enum.Parse(GetType(Season), input), Season)
$vbLabelText   $csharpLabel

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

IronPDF mit Enums in C# integrieren

IronPDF PDF-Bibliothek für die dynamische Dokumentenerstellung 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 nützlich sein in Szenarien, in denen eine dynamische PDF-Erstellung erforderlich ist, wie das Erstellen von Berichten oder Rechnungen. In diesem Abschnitt werden wir erkunden, wie IronPDF mit C#-Enums integriert werden kann, um PDF-Berichte aus HTML in .NET zu erstellen, und wir werden auch den Installationsprozess von IronPDF in Ihrem Projekt behandeln.

Mit IronPDF können Sie jedes HTML, jede URL oder Webseite in ein PDF umwandeln, das genau wie die Quelle aussieht. Es ist eine großartige Option, um PDFs für Rechnungen, Berichte und andere webbasierte Inhalte zu erstellen. Bereit, um 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
$vbLabelText   $csharpLabel

Installation von IronPDF

Die Installation von IronPDF ist sehr einfach über die NuGet-Paketmanager-Konsole. Öffnen Sie die Paketmanager-Konsole in Visual Studio und schreiben Sie den folgenden Befehl:

Install-Package IronPdf

Dieser Befehl wird IronPDF in unserem Projekt installieren.

Eine alternative Möglichkeit ist, IronPDF in Ihrem Projekt unter Nutzung von Visual Studio zu installieren. In Visual Studio, klicken Sie mit der rechten Maustaste auf den Lösungsexplorer und klicken Sie auf NuGet-Package-Manager für Lösungen. Anschließend klicken Sie auf die Registerkarte durchsuchen auf der linken Seite. Dann suchen Sie nach IronPDF, klicken Sie auf installieren und fügen Sie es Ihrem Projekt hinzu.

C#-Enumerationen (So funktioniert es für Entwickler): Abbildung 2 – Installieren Sie IronPDF, indem Sie mit dem NuGet Paketmanager nach

Verwendung von IronPDF mit Enums

Betrachten wir ein Szenario, in dem Sie ein PDF-Dokument generieren möchten, das einen Bericht über saisonale Verkaufsdaten enthält. Sie können Enums verwenden, um verschiedene Jahreszeiten darzustellen und IronPDF, um den PDF-Bericht zu erstellen. Zuerst, definieren Sie 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
$vbLabelText   $csharpLabel

Als nächstes schreiben wir eine Methode, die einen PDF-Bericht basierend auf der ausgewählten Jahreszeit erstellt. Diese Methode wird IronPDF nutzen, um ein einfaches PDF-Dokument zu erstellen, das Verkaufsdaten für die gegebene Jahreszeit umreißt.

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

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

Ausführung

Um einen saisonalen Verkaufsbericht zu generieren, rufen Sie die GenerateSeasonalSalesReport-Methode mit einer spezifischen Jahreszeit 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
$vbLabelText   $csharpLabel

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

C#-Enumerationen (So funktioniert es für Entwickler): Abbildung 3 – Beispiel einer PDF-Ausgabe mit IronPDF aus dem Codebeispiel

Abschluss

Enums in C# bieten eine typsichere Möglichkeit, mit Mengen verwandter benannter Konstanten zu arbeiten. Sie verbessern die Lesbarkeit des Codes, reduzieren Fehler und erleichtern sauberere Codeorganisation. Durch Gruppierung verwandter konstanter Werte unter einem bedeutungsvollen Namen machen Enums Ihren Code verständlicher und wartbarer.

Die Integration von IronPDF mit Enums in C# ermöglicht die dynamische Erstellung von PDF-Dokumenten basierend auf aufgezählten Typen. IronPDF bietet einen kostenlosen Test seiner umfassenden PDF-Tools, die eine Reihe von Optionen bieten, die auf unterschiedliche Projektbedürfnisse und -maßstäbe zugeschnitten sind.

Häufig gestellte Fragen

Was sind Enums in C# und warum sind sie nützlich?

Enums, kurz für Enumerationen, sind eine Funktion in C#, die es Entwicklern ermöglicht, eine Menge benannter Konstanten zu definieren. Dies verbessert die Code-Lesbarkeit und Wartung, da konstante Werte unter einem Namen gruppiert werden.

Wie deklariert und initialisiert man ein Enum in C#?

In C# deklarieren Sie ein Enum mit dem enum-Schlüsselwort, gefolgt vom Enum-Namen und seinen Mitgliedern. Zum Beispiel erstellt enum Season { Spring, Summer, Autumn, Winter } ein Enum namens Season mit vier Mitgliedern.

Können Enum-Mitglieder in C# benutzerdefinierte zugrundeliegende Werte haben?

Ja, Sie können Enum-Mitgliedern in C# bestimmte Ganzzahlen zuweisen, was es Ihnen ermöglicht, ihre numerische Darstellung zu steuern. Zum Beispiel weist enum ErrorCode { None = 0, NotFound = 404, Unauthorized = 401 } jedem Mitglied benutzerdefinierte Werte zu.

Wie konvertiert man einen Enum-Wert in eine Ganzzahl und umgekehrt in C#?

Um einen Enum-Wert in eine Ganzzahl zu konvertieren, verwenden Sie Casting, wie (int)Season.Autumn. Um eine Ganzzahl in ein Enum zu konvertieren, casten Sie die Ganzzahl in den Enum-Typ, wie (Season)4.

Was ist der Zweck des [Flags]-Attributs in C#-Enums?

Das [Flags]-Attribut in C# erlaubt es, ein Enum als eine Menge von Bit-Flags zu verwenden, wodurch Kombinationen von Werten in einer einzigen Variablen ermöglicht werden. Dies ist nützlich für Szenarien, in denen mehrere Werte zusammen dargestellt werden müssen, wie z.B. das Kombinieren von 'Read'- und 'Write'-Berechtigungen.

Wie kann man Enums zur Erstellung dynamischer PDF-Dokumente in C# nutzen?

Enums können verwendet werden, um verschiedene Kategorien oder Typen bei der dynamischen PDF-Dokumentenerstellung darzustellen. Beispielsweise kann ein 'Season'-Enum verwendet werden, um PDFs für saisonale Verkaufsberichte zu erstellen, indem der entsprechende Enum-Wert ausgewählt wird, um den Inhalt dynamisch anzupassen.

Was ist der Prozess zur Installation einer Bibliothek zur PDF-Erstellung in einem C#-Projekt?

Um eine PDF-Erstellungsbibliothek in einem C#-Projekt zu installieren, verwenden Sie die NuGet-Paketmanager-Konsole mit einem Befehl wie Install-Package [LibraryName], oder verwenden Sie die NuGet-Paketmanagement-oberfläche von Visual Studio für die Installation.

Wie können Enums mit Switch-Anweisungen in C# implementiert werden?

Enums können mit Switch-Anweisungen verwendet werden, um verschiedene Codeblöcke basierend auf dem Enum-Wert auszuführen. Zum Beispiel kann eine Switch-Anweisung auf einer 'Season'-Enum-Variablen spezifische Logik für jede Jahreszeit ausführen, was die Code-Klarheit und Organisation verbessert.

Wie analysiert man eine Zeichenkette in ein Enum in C#?

Um eine Zeichenkette in einen Enum-Wert in C# zu analysieren, können Sie die Methode Enum.Parse() verwenden. Beispielsweise konvertiert Enum.Parse(typeof(Season), "Winter") die Zeichenkette 'Winter' in ihren entsprechenden Enum-Wert 'Season.Winter'.

Welche Methoden stehen für die Arbeit mit Enum-Namen in C# zur Verfügung?

C# bietet Methoden wie Enum.GetName() und Enum.GetNames(), um mit Enum-Namen zu arbeiten. Enum.GetName() gibt den Namen der Konstante zurück, die den angegebenen Wert hat, während Enum.GetNames() ein Array der Namen aller Konstanten im Enum zurückgibt.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an