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 é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 à 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 est utilisé pour déclarer un type d'énumération, offrant un moyen de regrouper des valeurs constantes sous un seul 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 : Spring, Summer, Autumn et Winter. En définissant cet énumérateur, nous pouvons désormais créer des variables de type Season 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 attribue la valeur Autumn. Cela indique clairement que currentSeason ne peut contenir qu'une valeur valide de Season.

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, ce qui correspond à Autumn dans l'énumération Season. Inversement, saison sera défini sur Automne lorsque l'entier 4 sera de nouveau transformé en Saison.

Travailler avec les méthodes Enum

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.

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

Ce fragment de code affiche les noms de tous les membres de l'énumération 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 avec des valeurs entières personnalisées attribuées à chaque membre. 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 l'attribut [Flags], vous pouvez définir un enum 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'énumération Permissions définie ci-dessus, vous pouvez combiner différentes permissions en utilisant l'opérateur OR au niveau des bits.

Permissions myPermissions = Permissions.Read 
 Permissions.Write;

Permissions myPermissions = Permissions.Read 
 Permissions.Write;

Dim myPermissions As Permissions = Permissions.Read Permissions.Write

Cela définit myPermissions à une combinaison de permissions Read et Write.

Déclarations Enum et Switch

Les enums fonctionnent extrêmement 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é." car la variable saison est définie sur Season.Summer.

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

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

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 "Winter" en sa valeur enum correspondante Season.Winter.

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

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 en toute simplicité. 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 explorer comment intégrer IronPDF avec les enums C# pour créer des rapports PDF à partir de HTML en .NET, et nous aborderons é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 les factures, les rapports et d'autres contenus basés sur le web. Prêt à convertir HTML en PDF ? IronPDF facilite les choses.

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 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 un paramètre Season enum. Il utilise la classe ChromePdfRenderer d'IronPDF pour générer un PDF à partir d'une chaîne HTML qui inclut le nom de la saison et un texte de remplacement pour les données de ventes. 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 saisonnier, 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

Ce procédé génère un document PDF nommé WinterSalesReport.pdf, qui inclut le rapport de 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 des enums en C# permet la génération dynamique de documents PDF basés sur des types énumérés. IronPDF offre un essai gratuit de ses outils PDF complets, proposant une gamme d'options pour répondre aux différents besoins et échelles de projets.