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

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

Curtis Chau
Curtis Chau
Mis à jour:

En C#, un mot-clé const est un outil puissant pour définir des champs ou des valeurs constantes connus au moment de la compilation. Ces valeurs sont immuables, ce qui signifie qu'une fois définies, leur valeur ne peut pas être modifiée tout au long du programme. Utiliser const peut rendre votre code plus lisible et maintenable en fournissant une indication claire des valeurs qui doivent rester constantes. Dans cet article, nous allons discuter du mot-clé const et de la bibliothèque IronPDF.

Déclarer des variables constantes

Pour déclarer une variable constante, vous utilisez le mot-clé const suivi d'un type de données, et l'initialisez immédiatement. Par exemple, const int myConstValue = 100; définit une constante entière. Il est important de noter qu'une variable constante doit être initialisée lors de sa déclaration, car sa valeur est censée être connue à la compilation, et entièrement évaluée avant l'exécution du programme.

public class Program
{
    public const int MaxSize = 10;

    static void Main(string[] args)
    {
        Console.WriteLine(MaxSize);
    }
}
public class Program
{
    public const int MaxSize = 10;

    static void Main(string[] args)
    {
        Console.WriteLine(MaxSize);
    }
}
Public Class Program
	Public Const MaxSize As Integer = 10

	Shared Sub Main(ByVal args() As String)
		Console.WriteLine(MaxSize)
	End Sub
End Class
$vbLabelText   $csharpLabel

C# Const (Comment ça fonctionne pour les développeurs) : Figure 1 - Sortie Const

Cet exemple illustre une utilisation simple d'un entier constant (const int) dans une classe. La constante MaxSize est accessible dans la même classe et peut être utilisée directement dans la méthode static void Main.

const vs. readonly Variables

Bien que les mots-clés const et readonly soient utilisés pour déclarer des valeurs immuables, il existe des différences importantes entre eux. Un champ const est une constante de temps de compilation, ce qui signifie que sa valeur est déterminée à la compilation et intégrée directement dans le code en langue intermédiaire (IL). Cela le rend statique, et il ne peut pas être modifié.

En revanche, une variable readonly peut être assignée soit au moment de la déclaration, soit à l'intérieur d'un constructeur de la classe. Cela permet une certaine flexibilité, car les champs readonly peuvent avoir des valeurs différentes en fonction du constructeur utilisé pour instancier la classe.

public class Program
{
    public const string ConstExample = "Constant"; // const string
    public readonly string ReadonlyExample;

    public Program()
    {
        ReadonlyExample = "Initialized at runtime";
    }

    static void Main(string[] args)
    {
        Program p = new Program();
        Console.WriteLine(ConstExample);
        Console.WriteLine(p.ReadonlyExample);
    }
}
public class Program
{
    public const string ConstExample = "Constant"; // const string
    public readonly string ReadonlyExample;

    public Program()
    {
        ReadonlyExample = "Initialized at runtime";
    }

    static void Main(string[] args)
    {
        Program p = new Program();
        Console.WriteLine(ConstExample);
        Console.WriteLine(p.ReadonlyExample);
    }
}
Public Class Program
	Public Const ConstExample As String = "Constant" ' const string
	Public ReadOnly ReadonlyExample As String

	Public Sub New()
		ReadonlyExample = "Initialized at runtime"
	End Sub

	Shared Sub Main(ByVal args() As String)
		Dim p As New Program()
		Console.WriteLine(ConstExample)
		Console.WriteLine(p.ReadonlyExample)
	End Sub
End Class
$vbLabelText   $csharpLabel

C# Const (Comment ça fonctionne pour les développeurs) : Figure 2 - Sortie du champ Readonly

Périmètre des variables const

Les variables constantes peuvent être déclarées à l'intérieur d'une méthode ou en tant que membre d'une classe. Lorsque vous déclarez une variable const à l'intérieur d'une méthode, elle est appelée constante locale. Les constantes locales sont uniquement accessibles à l'intérieur de la méthode dans laquelle elles sont déclarées.

public class Program
{
    static void DemoMethod()
    {
        const int LocalConst = 5; // local constant
        Console.WriteLine(LocalConst);
    }
}
public class Program
{
    static void DemoMethod()
    {
        const int LocalConst = 5; // local constant
        Console.WriteLine(LocalConst);
    }
}
Public Class Program
	Private Shared Sub DemoMethod()
		Const LocalConst As Integer = 5 ' local constant
		Console.WriteLine(LocalConst)
	End Sub
End Class
$vbLabelText   $csharpLabel

C# Const (Comment ça fonctionne pour les développeurs) : Figure 3 - Sortie de la constante locale

En revanche, lorsque const est déclaré dans une classe mais en dehors de toute méthode, il est accessible depuis n'importe quelle fonction statique de cette classe, car les champs const sont implicitement statiques. Cependant, essayer d'accéder à un champ const à partir d'une méthode d'instance sans le référencer par le nom de la classe entraînera une erreur de compilation.

Constantes de temps de compilation vs. constantes de temps d'exécution

La caractéristique principale des valeurs const est qu'elles sont évaluées à la compilation. Cela signifie que la valeur d'un champ const doit être connue et complètement évaluée par le compilateur. Ceci est en contraste avec les variables qui sont évaluées au moment de l'exécution, dont les valeurs sont déterminées pendant l'exécution du programme.

Par exemple, tenter d'assigner une valeur à un champ const basé sur un calcul effectué au temps d'exécution entraînera une erreur de compilation. Le compilateur exige que les valeurs const soient assignées à partir d'expressions constantes ou de valeurs littérales connues à la compilation.

const double Pi = Math.PI; // This will cause a compile time error
const double Pi = Math.PI; // This will cause a compile time error
Const Pi As Double = Math.PI ' This will cause a compile time error
$vbLabelText   $csharpLabel

Utilisation avancée des constantes et membres statiques en C#

Au-delà des bases de const et readonly en C#, comprendre comment travailler avec des expressions constantes, des constructeurs statiques et des champs statiques peut améliorer vos pratiques de codage, notamment lorsqu'il s'agit de valeurs constantes à partager entre instances d'une classe.

Expressions constantes

Une expression constante en C# est une expression qui peut être entièrement évaluée à la compilation. Par conséquent, lorsque vous déclarez une variable const, le côté droit de sa déclaration doit être une expression constante. Cela garantit que la valeur const est fixée et peut être intégrée directement dans le code compilé, menant à des applications hautement optimisées et efficaces.

public class Calculator
{
    public const int Multiplier = 2;
    public const int DoubleMultiplier = Multiplier * 2; // Constant expression
}
public class Calculator
{
    public const int Multiplier = 2;
    public const int DoubleMultiplier = Multiplier * 2; // Constant expression
}
Public Class Calculator
	Public Const Multiplier As Integer = 2
	Public Const DoubleMultiplier As Integer = Multiplier * 2 ' Constant expression
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, DoubleMultiplier est une expression constante car elle est calculée à l'aide d'une autre valeur constante, ce qui la rend éligible pour être une constante de temps de compilation.

Constructeur statique

Un constructeur statique en C# est un constructeur spécial qui initialise les champs statiques de la classe. Il est appelé automatiquement avant que la première instance soit créée ou que des membres statiques ne soient référencés. Les constructeurs statiques sont utiles pour l'initialisation complexe de données statiques ou pour effectuer des actions qui doivent se produire une fois par type plutôt qu'une fois par instance.

public class Program
{
    public static readonly string StartTime;

    static Program()
    {
        StartTime = DateTime.Now.ToString("T");
    }

    public static void DisplayStartTime()
    {
        Console.WriteLine($"Program started at: {StartTime}");
    }
}
public class Program
{
    public static readonly string StartTime;

    static Program()
    {
        StartTime = DateTime.Now.ToString("T");
    }

    public static void DisplayStartTime()
    {
        Console.WriteLine($"Program started at: {StartTime}");
    }
}
Public Class Program
	Public Shared ReadOnly StartTime As String

	Shared Sub New()
		StartTime = DateTime.Now.ToString("T")
	End Sub

	Public Shared Sub DisplayStartTime()
		Console.WriteLine($"Program started at: {StartTime}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Le constructeur statique initialise le champ StartTime avec l'heure actuelle. Cette valeur est ensuite accessible via la méthode statique DisplayStartTime, montrant comment les constructeurs statiques peuvent être utilisés pour initialiser des champs readonly avec des valeurs qui ne sont pas connues avant l'exécution.

Champs statiques et les mots-clés readonly et static

Les champs statiques appartiennent à la classe plutôt qu'à une instance de la classe et sont déclarés en utilisant le mot-clé static. Lorsqu'ils sont combinés avec le mot-clé readonly, un champ statique peut être initialisé soit au moment de la déclaration soit au sein d'un constructeur statique et ne peut pas être modifié par la suite.

public class Configuration
{
    public static readonly int MaxUsers;
    public const int TimeoutSeconds = 30;

    static Configuration()
    {
        MaxUsers = FetchMaxUsersFromConfig();
    }

    private static int FetchMaxUsersFromConfig()
    {
        // Imagine this method reads from a configuration file
        return 100;
    }
}
public class Configuration
{
    public static readonly int MaxUsers;
    public const int TimeoutSeconds = 30;

    static Configuration()
    {
        MaxUsers = FetchMaxUsersFromConfig();
    }

    private static int FetchMaxUsersFromConfig()
    {
        // Imagine this method reads from a configuration file
        return 100;
    }
}
Public Class Configuration
	Public Shared ReadOnly MaxUsers As Integer
	Public Const TimeoutSeconds As Integer = 30

	Shared Sub New()
		MaxUsers = FetchMaxUsersFromConfig()
	End Sub

	Private Shared Function FetchMaxUsersFromConfig() As Integer
		' Imagine this method reads from a configuration file
		Return 100
	End Function
End Class
$vbLabelText   $csharpLabel

Cet exemple démontre l'utilisation d'un constructeur qui est statique pour initialiser un champ readonly statique, MaxUsers, avec une valeur récupérée à l'exécution, peut-être à partir d'un fichier de configuration. Le champ const, TimeoutSeconds, représente une constante de temps de compilation qui est directement intégrée dans le code.

Introduction à IronPDF

C# Const (Comment ça fonctionne pour les développeurs) : Figure 4 - IronPDF

IronPDF est une bibliothèque polyvalente qui permet aux développeurs de créer, éditer et lire des documents PDF dans les applications .NET. Cet outil puissant simplifie la génération de PDF en permettant aux développeurs de convertir du HTML en PDF, manipuler du contenu, et extraire des données de fichiers PDF avec aisance.

La force d'IronPDF réside dans la conversion de HTML en PDF, en préservant à la fois la mise en page et le style. C'est un outil idéal pour générer des PDF à partir de contenu web, comme des rapports, des factures et de la documentation. Les fichiers HTML, les URLs et les chaînes HTML peuvent facilement être convertis en fichiers 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");
    }
}
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

Commencer avec IronPDF et exemple const

Pour démontrer comment IronPDF peut être intégré dans un projet .NET, examinons un exemple simple où nous utilisons une constante pour définir la chaîne HTML que nous souhaitons convertir en document PDF.

using IronPdf;

public class PdfGenerator
{
    // Defining a constant HTML template
    public const string HtmlTemplate = @"
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>";

    public static void CreatePdf(string filePath)
    {
        IronPdf.License.LicenseKey = "License";

        // Create a new PDF document from HTML template
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(HtmlTemplate);

        // Save the PDF document to a file
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator.CreatePdf("example.pdf");
    }
}
using IronPdf;

public class PdfGenerator
{
    // Defining a constant HTML template
    public const string HtmlTemplate = @"
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>";

    public static void CreatePdf(string filePath)
    {
        IronPdf.License.LicenseKey = "License";

        // Create a new PDF document from HTML template
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(HtmlTemplate);

        // Save the PDF document to a file
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator.CreatePdf("example.pdf");
    }
}
Imports IronPdf

Public Class PdfGenerator
	' Defining a constant HTML template
	Public Const HtmlTemplate As String = "
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>"

	Public Shared Sub CreatePdf(ByVal filePath As String)
		IronPdf.License.LicenseKey = "License"

		' Create a new PDF document from HTML template
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(HtmlTemplate)

		' Save the PDF document to a file
		pdf.SaveAs(filePath)
		Console.WriteLine($"PDF generated successfully at {filePath}")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		PdfGenerator.CreatePdf("example.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, la constante HtmlTemplate est définie avec du contenu HTML simple qui sert de source pour notre document PDF. La méthode CreatePdf utilise la classe ChromePdfRenderer d'IronPDF pour convertir ce HTML en PDF et le sauvegarder dans le chemin de fichier spécifié. Cela montre la facilité avec laquelle IronPDF peut être utilisé pour générer des PDF à partir de contenu HTML statique, en utilisant le mot-clé const pour définir des modèles HTML immuables.

Sortie

Voici le fichier PDF de sortie :

C# Const (Comment ça fonctionne pour les développeurs) : Figure 5 - Sortie PDF

Conclusion

C# Const (Comment ça fonctionne pour les développeurs) : Figure 6 - Licence

En C#, le mot-clé const est une fonctionnalité précieuse pour définir des valeurs immuables connues au moment de la compilation. Il aide à améliorer la lisibilité et la maintenabilité de votre code en indiquant clairement quelles valeurs sont des constantes. Rappelez-vous, les variables const sont implicitement statiques, doivent être initialisées à la déclaration, et leurs valeurs doivent être des constantes de temps de compilation. Comparativement, les variables readonly offrent plus de flexibilité mais sont initialisées au temps d'exécution.

IronPDF se distingue non seulement pour ses fonctionnalités robustes en matière de manipulation de PDF mais aussi pour son modèle d'adoption flexible. Pour les développeurs et les organisations souhaitant explorer ses capacités, IronPDF offre une version d'essai gratuite, fournissant une excellente opportunité d'évaluer ses fonctionnalités et la facilité d'intégration sans investissement initial.

Quand vous êtes prêt à avancer avec IronPDF pour un usage commercial, les options de licence commencent à partir de $799. Cette structure tarifaire est conçue pour répondre aux besoins de différents tailles et types de projets, garantissant que vous pouvez choisir une licence qui correspond le mieux à vos plans de développement et de distribution.

Questions Fréquemment Posées

Quel est le but du mot clé const en C#?

En C#, le mot clé const est utilisé pour définir des champs ou des valeurs constantes connues au moment de la compilation, les rendant immuables tout au long du programme.

Comment déclarez-vous une variable constante en C#?

Une variable constante est déclarée à l'aide du mot clé const suivi d'un type de données et d'une valeur initiale. Par exemple, const int myConstValue = 100;.

Quelle est la différence entre const et readonly en C#?

Un const est une constante au moment de la compilation et doit être initialisé lors de la déclaration. Il est statique et ne peut pas être modifié. Une variable readonly peut être assignée au moment de la déclaration ou dans un constructeur, permettant une initialisation à l'exécution.

Une variable const peut-elle être déclarée au sein d'une méthode en C#?

Oui, une variable const peut être déclarée au sein d'une méthode, connue sous le nom de constante locale, et n'est accessible que dans cette méthode.

Comment IronPDF convertit-il HTML en PDF?

IronPDF convertit HTML en PDF en utilisant la classe ChromePdfRenderer, qui peut rendre des chaînes HTML, des fichiers ou des URLs en documents PDF.

Comment une bibliothèque peut-elle être utilisée avec des constantes C#?

IronPDF peut utiliser des constantes C#, comme une chaîne de modèle HTML constante, pour générer des documents PDF en convertissant efficacement du contenu HTML en PDFs.

Pourquoi utiliser IronPDF dans les applications .NET?

IronPDF est utilisé pour créer, éditer et lire des documents PDF dans les applications .NET, simplifiant la génération de PDF en convertissant HTML en PDF tout en préservant la mise en page et le style.

Quelles sont les constantes au moment de la compilation en C#?

Les constantes au moment de la compilation sont des valeurs évaluées et fixées au moment de la compilation. Le mot clé const garantit qu'une variable est une constante au moment de la compilation.

Qu'est-ce qu'un constructeur statique en C#?

Un constructeur statique initialise les champs statiques d'une classe et est appelé automatiquement avant la création de toute instance ou l'accès aux membres statiques.

Qu'est-ce qu'une expression constante en C#?

Une expression constante est une expression qui peut être entièrement évaluée au moment de la compilation, ce qui lui permet d'être utilisée dans une déclaration const.

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