Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Les énumérations C#
.NET AIDE

C# Enums (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Contenu du corps : Les énumérations, qui sont des abréviations pour les énumérations, servent de fonctionnalité puissante qui permet aux développeurs de créer un ensemble de constantes nommées. Ces constantes rendent le code plus lisible et plus facile à maintenir en fournissant des noms significatifs pour les valeurs. Dans cet article, nous explorerons les concepts de base et avancés des énumérations en C# à travers divers exemples et explications. Notre objectif est de fournir une compréhension approfondie des énumérations et de la manière dont elles peuvent être utilisées efficacement dans vos applications C# en utilisant la bibliothèque IronPDF pour la génération de PDF en .NET.

Introduction aux énumérations en C#

Une énumération est un type valeur en C# qui permet à une variable d'être un ensemble de constantes prédéfinies, chacune étant appelée un membre de l'énumération. Le mot-clé enum est utilisé pour déclarer un type d'énumération, fournissant un moyen de regrouper des valeurs constantes sous un seul nom. Les énumérations améliorent la lisibilité du code et réduisent les erreurs causées par le passage de mauvaises valeurs.

// 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

Dans le code ci-dessus, Season est un type d'énumération avec quatre membres : Printemps, Été, Automne et Hiver. En définissant cette énumération, nous pouvons désormais créer des variables de type Season qui ne peuvent contenir qu'une de ces quatre valeurs.

Type sous-jacent des énumérations

Compréhension de la valeur entière des membres d'une énumération

Par défaut, le type sous-jacent d'une énumération en C# est int, connu sous le nom de type entier sous-jacent, et les valeurs entières des membres de l'énumération commencent à 0. La valeur entière de chaque membre est incrémentée de 1 par rapport au membre précédent, sauf indication contraire. Vous pouvez également définir le type sous-jacent d'une énumération comme n'importe quel autre type entier.

// 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

Dans cet exemple, l'énumération Season a un octet comme type sous-jacent. Printemps se voit attribuer explicitement une valeur de 1, ce qui en fait la valeur par défaut, tandis qu'Été, Automne et Hiver se voient attribuer des valeurs correspondantes en fonction de leur ordre.

Utilisation des énumérations dans votre code

Pour utiliser une énumération, il suffit de déclarer une variable du type d'énumération spécifié et de lui attribuer une valeur de l'énumération, telle qu'une des différentes valeurs définies dans la déclaration de l'énumération, à l'aide de la syntaxe pointée.

// 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

Cette ligne crée une variable currentSeason du type Season et lui attribue la valeur Autumn. Cela rend clair que currentSeason ne peut contenir qu'une valeur qui est un Season valide.

Conversion entre les valeurs d'énumération et les entiers

Vous pouvez convertir une valeur d'énumération en sa valeur entière correspondante en utilisant le transtypage, et vice versa. Ceci est utile lorsque vous devez stocker ou transmettre des données sous forme numérique.

// 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

Ici, autumnInt aura la valeur 4, qui correspond à Autumn dans l'énumération Season. Inversement, season sera défini sur Autumn lorsqu'un entier 4 sera retranstypé en un Season.

Travailler avec les méthodes d'énumération

C# fournit plusieurs méthodes pour travailler avec les énumérations, telles que Enum.GetName(), Enum.GetNames(), Enum.GetValue(), et Enum.GetValues(), qui sont utiles pour accéder aux constantes entières associées à chaque membre de l'énumération.

// 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

!Énumérations C# (Comment cela fonctionne pour les développeurs) : Figure 1 - Sortie console de chaque valeur associée à l'énumération Season

Ce code extrait imprime les noms de tous les membres de l'énumération Season. De telles méthodes sont extrêmement utiles pour parcourir toutes les valeurs possibles d'une énumération ou pour convertir entre la représentation en chaîne et la valeur de l'énumération.

Attribution de valeurs spécifiques aux membres de l'énumération

Vous pouvez attribuer des valeurs entières spécifiques aux membres d'une énumération pour contrôler explicitement leur valeur numérique.

// 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

Dans cet exemple, ErrorCode est une énumération avec des valeurs entières personnalisées attribuées à chaque membre. Cela est utile pour les codes numériques prédéfinis, tels que les codes d'état HTTP.

Utilisation des énumérations comme indicateurs de bits

En utilisant l'attribut [Flags], vous pouvez définir une énumération comme un ensemble d'indicateurs de bits. Cela vous permet de stocker une combinaison de valeurs dans une seule variable d'énumération.

[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

Avec l'énumération Permissions définie ci-dessus, vous pouvez combiner différents droits à l'aide de l'opérateur de comparaison « ou » binaire.

// 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

Cela définit myPermissions sur une combinaison de droits Read et Write.

Énumération et instructions switch

Les énumérations fonctionnent exceptionnellement bien avec les instructions switch, vous permettant d'exécuter différents blocs de code en fonction de la valeur de l'énumération.

// 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

Ce code imprimera « C'est l'été. » parce que la variable season est définie sur Season.Summer.

Analyse de chaîne en énumération

C# vous permet d'analyser une chaîne pour obtenir la valeur d'énumération correspondante en utilisant la méthode Enum.Parse().

// 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

Ce code convertit la chaîne "Winter" en sa valeur d'énumération correspondante Season.Winter.

Intégration d'IronPDF avec les énumérations en C#

IronPDF PDF Library for Dynamic Document Generation est une bibliothèque PDF pour les applications .NET qui aide les développeurs à créer, éditer et manipuler des documents PDF facilement. Cette bibliothèque puissante peut être particulièrement utile dans des scénarios où la génération de PDF dynamique est requise, comme lors de la création de rapports ou de factures. Dans cette section, nous explorerons comment intégrer IronPDF avec les énumérations C# pour créer des rapports PDF à partir de HTML en .NET, et nous couvrirons également le processus d'installation d'IronPDF dans votre projet.

Avec IronPDF, vous pouvez transformer n'importe quel HTML, URL ou page Web en un PDF qui ressemble exactement à la source. C'est une excellente option pour générer des PDF pour des factures, des rapports et d'autres contenus Web. Prêt à convertir HTML en PDF? IronPDF rend cela sans effort.

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

Installer IronPDF

L'installation d'IronPDF est très facile avec la console du gestionnaire de packages NuGet. Ouvrez la console du gestionnaire de packages dans Visual Studio et écrivez la commande suivante :

Install-Package IronPdf

Cette commande installera IronPDF dans notre projet.

Une autre manière est d'installer IronPDF dans votre projet en utilisant Visual Studio. Dans Visual Studio, faites un clic droit sur l'explorateur de solutions et cliquez sur Gestionnaire de packages NuGet pour Solutions. Ensuite, cliquez sur l'onglet de navigation sur le côté gauche. Ensuite, recherchez IronPDF, cliquez sur installer et ajoutez-le à votre projet.

!Énumérations C# (Comment cela fonctionne pour les développeurs) : Figure 2 - Installer IronPDF en recherchant « IronPDF » avec le gestionnaire de packages NuGet

Utilisation d'IronPDF avec les énumérations

Considérons un scénario où vous souhaitez générer un document PDF incluant un rapport sur les données de vente saisonnières. Vous pouvez utiliser des énumérations pour représenter différentes saisons et IronPDF pour générer le rapport PDF. Tout d'abord, définissez une énumération pour les saisons :

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

Ensuite, nous écrirons une méthode qui génère un rapport PDF basé sur la saison sélectionnée. Cette méthode utilisera IronPDF pour créer un document PDF simple qui présente les données de vente pour la saison donnée.

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

Dans cet exemple, nous définissons une méthode GenerateSeasonalSalesReport qui prend une énumération Season comme paramètre. Elle utilise la classe ChromePdfRenderer d'IronPDF pour générer un PDF à partir d'une chaîne HTML incluant le nom de la saison et un texte de remplacement pour les données de vente. Le PDF est ensuite enregistré avec un nom de fichier incluant le nom de la saison.

Exécution

Pour générer un rapport de ventes saisonnières, appelez la méthode GenerateSeasonalSalesReport avec une saison spécifique :

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

Cet appel génère un document PDF nommé WinterSalesReport.pdf, qui inclut le rapport de ventes pour la saison hivernale.

!Énumérations C# (Comment cela fonctionne pour les développeurs) : Figure 3 - Exemple de sortie PDF utilisant IronPDF depuis l'exemple de code

Conclusion

Les énumérations en C# offrent un moyen sécurisé de type pour travailler avec des ensembles de constantes nommées apparentées. Elles améliorent la lisibilité du code, réduisent les erreurs et facilitent une meilleure organisation du code. En groupant des valeurs constantes apparentées sous un nom significatif, les énumérations rendent votre code plus facile à comprendre et à maintenir.

L'intégration d'IronPDF avec les énumérations en C# permet la génération dynamique de documents PDF basés sur les types énumérés. IronPDF offre un essai gratuit de ses outils PDF complets, fournissant une gamme d'options adaptées aux différents besoins et échelles de projet.

Questions Fréquemment Posées

Qu'est-ce que les énumérations en C# et pourquoi sont-elles utiles ?

Les énumérations, abrégées en enums, sont une fonctionnalité en C# qui permet aux développeurs de définir un ensemble de constantes nommées. Cela améliore la lisibilité et la maintenance du code car il regroupe les valeurs constantes sous un seul nom.

Comment déclarez-vous et initialisez-vous une énumération en C# ?

En C#, vous déclarez une énumération en utilisant le mot-clé enum suivi du nom de l'énumération et de ses membres. Par exemple, enum Season { Spring, Summer, Autumn, Winter } crée une énumération nommée Season avec quatre membres.

Les membres d'une énumération en C# peuvent-ils avoir des valeurs sous-jacentes personnalisées ?

Oui, vous pouvez attribuer des valeurs entières spécifiques aux membres d'une énumération en C#, ce qui vous permet de contrôler leur représentation numérique. Par exemple, enum ErrorCode { None = 0, NotFound = 404, Unauthorized = 401 } attribue des valeurs personnalisées à chaque membre.

Comment convertissez-vous une valeur d'énumération en entier et vice-versa en C# ?

Pour convertir une valeur d'énumération en entier, utilisez le casting, tel que (int)Season.Autumn. Pour convertir un entier en énumération, convertissez l'entier en type énumération, comme (Season)4.

Quel est le but de l'attribut [Flags] dans les énumérations C# ?

L'attribut [Flags] en C# permet d'utiliser une énumération comme un ensemble de bits de drapeaux, permettant des combinaisons de valeurs dans une seule variable. Ceci est utile dans les scénarios où plusieurs valeurs doivent être représentées ensemble, comme combiner les permissions 'Lire' et 'Écrire'.

Comment pouvez-vous utiliser les énumérations pour générer des documents PDF dynamiques en C# ?

Les énumérations peuvent être utilisées pour représenter différentes catégories ou types lors de la génération de documents PDF dynamiques. Par exemple, une énumération 'Season' peut être utilisée pour créer des PDF de rapports de ventes saisonniers en sélectionnant la valeur d'énumération appropriée pour ajuster dynamiquement le contenu.

Quel est le processus pour installer une bibliothèque pour la génération de PDF dans un projet C# ?

Pour installer une bibliothèque de génération de PDF dans un projet C#, utilisez la console du gestionnaire de paquets NuGet avec une commande comme Install-Package [LibraryName], ou utilisez l'interface du gestionnaire de paquets NuGet de Visual Studio pour l'installation.

Comment les énumérations peuvent-elles être mises en œuvre avec des instructions switch en C# ?

Les énumérations peuvent être utilisées avec des instructions switch pour exécuter différents blocs de code en fonction de la valeur de l'énumération. Par exemple, une instruction switch sur une variable d'énumération 'Season' peut exécuter une logique spécifique pour chaque saison, améliorant ainsi la clarté et l'organisation du code.

Comment analysez-vous une chaîne de caractères en énumération en C# ?

Pour analyser une chaîne de caractères en une valeur d'énumération en C#, vous pouvez utiliser la méthode Enum.Parse(). Par exemple, Enum.Parse(typeof(Season), "Winter") convertit la chaîne 'Winter' en sa valeur d'énumération correspondante 'Season.Winter'.

Quelles méthodes sont disponibles pour travailler avec les noms d'énumération en C# ?

C# fournit des méthodes telles que Enum.GetName() et Enum.GetNames() pour travailler avec les noms d'énumération. Enum.GetName() renvoie le nom de la constante ayant la valeur spécifiée, tandis que Enum.GetNames() renvoie un tableau des noms de toutes les constantes de l'énumération.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit