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

Les Enums, abréviation de "énumérations", constituent une fonctionnalité puissante qui permet aux développeurs d'établir 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 allons explorer les bases et les concepts avancés des enums en C# à travers divers exemples et explications. Notre objectif est de fournir une compréhension complète des enums et de la façon dont ils peuvent être utilisés efficacement dans vos applications C# à l'aide de l'outil de gestion des enumsIronPDF library for PDF generation in .NET (bibliothèque IronPDF pour la génération de PDF en .NET).

Introduction à Enum dans C# ;

Un enum est un type de valeur en C# qui permet à une variable d'être un ensemble de constantes prédéfinies, chacune étant appelée membre de l'enum. Le mot-clé enum permet de déclarer un type d'énumération, ce qui permet de regrouper des valeurs constantes sous un même nom. Les Enums améliorent la lisibilité du code et réduisent les erreurs dues à la transmission de valeurs incorrectes.

enum Season { Spring, Summer, Autumn, Winter }

enum Season { Spring, Summer, Autumn, Winter }

Friend Enum Season
	Spring
	Summer
	Autumn
	Winter
End Enum

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

Type sous-jacent des Enums

Comprendre 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 comme le type intégral 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, à moins que cela ne soit explicitement spécifié. Vous pouvez également définir le type sous-jacent d'une énumération comme étant n'importe quel autre type intégral.

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

Dans cet exemple, Saison est une énumération, désignée ici par le nom de l'énumération, dont le type sous-jacent est un octet. La valeur 1 est explicitement attribuée au printemps, ce qui en fait la valeur par défaut, tandis que les valeurs correspondantes sont attribuées à l'été, à l'automne et à l'hiver en fonction de leur ordre.

Utilisation des Enums 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 d'une énumération, telle que l'une des différentes valeurs définies dans la déclaration de l'énumération, à l'aide de la syntaxe point.

Season currentSeason = Season.Autumn;

Season currentSeason = Season.Autumn;

Dim currentSeason As Season = Season.Autumn

Cette ligne crée une variable currentSeason de type Season et lui affecte la valeur Autumn. Il est donc clair que currentSeason ne peut contenir qu'une valeur qui est une Season valide.

Conversion entre les valeurs des énumérations et les nombres entiers

Vous pouvez convertir une valeur d'énumération en sa valeur entière correspondante à l'aide d'une valeur intégrale donnée, et vice versa. Cette fonction est utile lorsque vous devez stocker ou transmettre des données sous forme numérique.

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)

Ici, autumnInt aura la valeur 4, qui correspond à Autumn dans l'enum Season. Inversement, saison sera mis à Automne lorsque l'entier 4 est converti en Saison.

Travailler avec les méthodes Enum

C# propose plusieurs méthodes pour travailler avec les enums, comme Enum.GetName(), Enum.GetNames(), Enum.GetValue(), et Enum.GetValues(), qui sont utiles pour accéder aux constantes int associées à chaque membre de l'enum.

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

Cet extrait de code affiche les noms de tous les membres de l'enum Season. Ces méthodes sont extrêmement utiles pour parcourir toutes les valeurs possibles d'une énumération ou pour convertir la représentation de la chaîne de caractères et la valeur de l'énumération.

Attribution de valeurs spécifiques aux membres d'une énumération

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

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

Dans cet exemple, ErrorCode est un enum dont chaque membre se voit attribuer une valeur entière personnalisée. Cette fonction est utile pour les codes numériques prédéfinis, tels que les codes d'état HTTP.

Utilisation des Enums comme indicateurs de bits

En utilisant les [Drapeaux] attribut, vous pouvez définir une énumération comme un ensemble de drapeaux de bits. Cela vous permet de stocker une combinaison de valeurs dans une seule variable enum.

[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

Avec l'enum Permissions défini ci-dessus, vous pouvez combiner différentes permissions en utilisant l'opérateur bitwise OR.

Permissions myPermissions = Permissions.Read 
 Permissions.Write;

Permissions myPermissions = Permissions.Read 
 Permissions.Write;

Dim myPermissions As Permissions = Permissions.Read Permissions.Write

Ceci définit mesPermissions à une combinaison de Lecture et Écriture.

Déclarations Enum et Switch

Les enums fonctionnent exceptionnellement bien avec les instructions switch, vous permettant d'exécuter différents blocs de code en fonction de la valeur de l'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;
}

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

Ce code affichera "C'est l'été" parce que la variable saison est définie sur Saison.été.

Parsing String to Enum (analyse d'une chaîne de caractères vers une énumération)

C# vous permet d'analyser une chaîne de caractères pour obtenir la valeur correspondante de l'enum à l'aide de la fonction Enum.Parse() méthode.

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)

Ce code convertit la chaîne "Hiver " en sa valeur enum correspondante Season.Winter.

Intégration d'IronPDF avec les Enums dans C&num ;

IronPDF PDF Library for Dynamic Document Generation (Bibliothèque PDF IronPDF pour la génération dynamique de documents) est une bibliothèque PDF pour les applications .NET qui permet aux développeurs de créer, d'éditer et de manipuler facilement des documents PDF. Cette puissante bibliothèque peut s'avérer particulièrement utile dans les scénarios où la génération dynamique de PDF est nécessaire, comme la génération de rapports ou de factures. Dans cette section, nous allons voir comment intégrer IronPDF avec les enums de C# pourcréer des rapports PDF à partir de HTML en .NETnous aborderons également le processus d'installation d'IronPDF dans votre projet.

Installation d'IronPDF

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

Install-Package IronPdf

Cette commande installera IronPDF dans notre projet.

Une autre solution consiste à installer IronPDF dans votre projet à l'aide de Visual Studio. Dans Visual Studio, faites un clic droit sur l'explorateur de solutions et cliquez sur NuGet Package Manager for Solutions. Cliquez ensuite sur l'onglet Parcourir sur le côté gauche. Ensuite, recherchez IronPDF, cliquez sur installer et ajoutez-le à votre projet.

Utiliser IronPDF avec des Enums

Prenons l'exemple d'un scénario dans lequel vous souhaitez générer un document PDF contenant un rapport sur les ventes saisonnières. Vous pouvez utiliser des énums pour représenter les 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

Ensuite, nous allons écrire une méthode qui génère un rapport PDF basé sur la saison sélectionnée. Cette méthode utilise IronPDF pour créer un simple document PDF 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

Dans cet exemple, nous définissons une méthode GenerateSeasonalSalesReport qui prend en paramètre un enum Season. Il utilise la classe ChromePdfRenderer d'IronPDF pour générer un PDF à partir d'une chaîne HTML qui comprend 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 comprenant 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

Cet appel génère un document PDF nommé WinterSalesReport.pdf, qui comprend le rapport des ventes pour la saison d'hiver.

Conclusion

Les Enums en C# offrent un moyen sûr de travailler avec des ensembles de constantes nommées apparentées. Ils améliorent la lisibilité du code, réduisent les erreurs et facilitent l'organisation du code. En regroupant des valeurs constantes apparentées sous un nom significatif, les enums facilitent la compréhension et la maintenance de votre code.

L'intégration d'IronPDF avec les énumérations en C# permet la génération dynamique de documents PDF basés sur des types énumérés. IronPDF offre un service deessai gratuit de ses outils PDF completsla traduction doit également être adaptée aux besoins et à l'échelle des projets, en proposant un éventail d'options.