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

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

Curtis Chau
Curtis Chau
Mis à jour:

L'opérateur 'nameof', introduit dans C# 6.0, est une construction au moment de la compilation conçue pour répondre au défi de se référer à des éléments de programme par leurs noms et au comportement d'exécution silencieusement cassé. Son principal objectif est d'éliminer le besoin de chaînes de caractères codées en dur, offrant une approche plus maintenable et résistante aux erreurs. Dans cet article, nous explorerons l'opérateur nameof en C# et introduirons également la bibliothèque IronPDF sur NuGet pour générer des documents PDF par programmation.

Syntaxe de base de l'opérateur 'nameof'

La syntaxe fondamentale de l'opérateur 'nameof' est simple. Il prend un élément en argument et renvoie son nom sous forme de chaîne. Considérez l'exemple suivant :

static void Main()
{
    // Declare a string variable
    string myVariable = nameof(myVariable);
    Console.WriteLine(myVariable); // Output: "myVariable"
}
static void Main()
{
    // Declare a string variable
    string myVariable = nameof(myVariable);
    Console.WriteLine(myVariable); // Output: "myVariable"
}
Shared Sub Main()
	' Declare a string variable
	Dim myVariable As String = NameOf(myVariable)
	Console.WriteLine(myVariable) ' Output: "myVariable"
End Sub
$vbLabelText   $csharpLabel

Dans ce cas, 'nameof(myVariable)' produit la chaîne "myVariable". L'opérateur peut être appliqué à divers éléments de code, y compris les variables, les types, les membres, et plus encore.

Avantages de l'opérateur 'nameof'

Maintenabilité du code

Un des avantages majeurs de l'opérateur 'nameof' est son impact positif sur la maintenabilité du code. Au lieu de coder en dur les noms sous forme de chaînes, les développeurs peuvent utiliser 'nameof', garantissant que les références se mettent à jour automatiquement lorsque les noms changent.

static void Main()
{
    // Without using nameof
    Logger.Log("Error: The variable 'myVariable' is null.");
    // Using nameof for improved maintainability
    Logger.Log($"Error: The variable '{nameof(myVariable)}' is null.");
}
static void Main()
{
    // Without using nameof
    Logger.Log("Error: The variable 'myVariable' is null.");
    // Using nameof for improved maintainability
    Logger.Log($"Error: The variable '{nameof(myVariable)}' is null.");
}
Shared Sub Main()
	' Without using nameof
	Logger.Log("Error: The variable 'myVariable' is null.")
	' Using nameof for improved maintainability
	Logger.Log($"Error: The variable '{NameOf(myVariable)}' is null.")
End Sub
$vbLabelText   $csharpLabel

Sécurité au moment de la compilation

'nameof' améliore la sécurité au moment de la compilation en éliminant le risque de fautes de frappe ou d'incohérences dans les noms. Toute faute d'orthographe ou modification d'un nom de variable déclenche une erreur au moment de la compilation, réduisant ainsi les risques de problèmes à l'exécution.

static void Main()
{
    // Compile-time error if 'myVariable' is misspelled
    string myVariable;
    string variableName = nameof(myVariable);

    Console.WriteLine(variableName);
}
static void Main()
{
    // Compile-time error if 'myVariable' is misspelled
    string myVariable;
    string variableName = nameof(myVariable);

    Console.WriteLine(variableName);
}
Shared Sub Main()
	' Compile-time error if 'myVariable' is misspelled
	Dim myVariable As String
	Dim variableName As String = NameOf(myVariable)

	Console.WriteLine(variableName)
End Sub
$vbLabelText   $csharpLabel

Support de refactoring

L'opérateur 'nameof' s'intègre parfaitement avec les outils de refactoring, offrant une expérience sans tracas lors du renommage de variables, types ou membres. Toutes les références 'nameof' sont mises à jour automatiquement.

static void Main()
{
    // Before renaming local variable 'myVariable' to 'newVariable'
    string myVariableNameChange = nameof(myVariableNameChange);
    // After renaming local variable 'myVariable' to 'newVariable'
    string newVariableNameChange = nameof(newVariableNameChange);

    Console.WriteLine(newVariableNameChange);
}
static void Main()
{
    // Before renaming local variable 'myVariable' to 'newVariable'
    string myVariableNameChange = nameof(myVariableNameChange);
    // After renaming local variable 'myVariable' to 'newVariable'
    string newVariableNameChange = nameof(newVariableNameChange);

    Console.WriteLine(newVariableNameChange);
}
Shared Sub Main()
	' Before renaming local variable 'myVariable' to 'newVariable'
	Dim myVariableNameChange As String = NameOf(myVariableNameChange)
	' After renaming local variable 'myVariable' to 'newVariable'
	Dim newVariableNameChange As String = NameOf(newVariableNameChange)

	Console.WriteLine(newVariableNameChange)
End Sub
$vbLabelText   $csharpLabel

Débogage amélioré

Pendant le débogage, 'nameof' rend le code plus informatif et lisible. Les instructions de journalisation, les messages d'exceptions et autres sorties de débogage deviennent concises et contextuellement pertinentes.

static void Main()
{
    // Without using nameof
    // throw new ArgumentNullException("myVariable", "The variable cannot be null."); 
    // Using nameof for improved debugging 
    throw new ArgumentNullException(nameof(myVariable), "The variable cannot be null.");
}
static void Main()
{
    // Without using nameof
    // throw new ArgumentNullException("myVariable", "The variable cannot be null."); 
    // Using nameof for improved debugging 
    throw new ArgumentNullException(nameof(myVariable), "The variable cannot be null.");
}
Shared Sub Main()
	' Without using nameof
	' throw new ArgumentNullException("myVariable", "The variable cannot be null."); 
	' Using nameof for improved debugging 
	Throw New ArgumentNullException(NameOf(myVariable), "The variable cannot be null.")
End Sub
$vbLabelText   $csharpLabel

Ici, le throw new ArgumentNullException lance une exception si la variable n'est pas déclarée.

Cas d'utilisation pratique de l'opérateur 'nameof'

Réflexion

En travaillant avec la réflexion, l'opérateur 'nameof' simplifie l'obtention des noms de types, propriétés ou méthodes sans utiliser de chaînes de caractères codées en dur.

Type type = typeof(MyClass);
string typeName = nameof(MyClass);
Type type = typeof(MyClass);
string typeName = nameof(MyClass);
Dim type As Type = GetType([MyClass])
Dim typeName As String = NameOf([MyClass])
$vbLabelText   $csharpLabel

La classe exemple MyClass peut être une chaîne codée en dur, mais nous pouvons utiliser la réflexion pour obtenir le nom de la classe dynamiquement. La variable type a le nom de la classe, puis le mot-clé nameof est utilisé pour obtenir le nom d'une instance de classe. Ils ne portent pas le même nom.

Journalisation et gestion des exceptions

'nameof' s'avère inestimable dans les instructions de journalisation et les messages d'exceptions, les rendant plus lisibles et moins sujettes aux erreurs.

Logger.Log($"Error: The property '{nameof(MyClass.MyProperty)}' is out of range.");
Logger.Log($"Error: The property '{nameof(MyClass.MyProperty)}' is out of range.");
Logger.Log($"Error: The property '{NameOf([MyClass].MyProperty)}' is out of range.")
$vbLabelText   $csharpLabel

Exemple

Dans cet exemple, nous créerons une simple classe représentant une personne, et nous utiliserons l'opérateur nameof pour améliorer les journaux et les messages d'erreurs.

using System;

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    // Method that displays the full name of the person
    public void DisplayFullName()
    {
        if (string.IsNullOrEmpty(FirstName) || string.IsNullOrEmpty(LastName))
        {
            LogError($"Invalid name: {nameof(FirstName)} or {nameof(LastName)} is missing.");
        }
        else
        {
            Console.WriteLine($"Full Name: {FirstName} {LastName}");
        }
    }

    // Custom error logging method that highlights errors
    private void LogError(string errorMessage)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"Error: {errorMessage}");
        Console.ResetColor();
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of the Person class
        Person person = new Person();

        // Attempt to display the full name without setting the properties
        person.DisplayFullName();

        // Set the properties and display the full name again
        person.FirstName = "John";
        person.LastName = "Doe";
        person.DisplayFullName();
    }
}
using System;

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    // Method that displays the full name of the person
    public void DisplayFullName()
    {
        if (string.IsNullOrEmpty(FirstName) || string.IsNullOrEmpty(LastName))
        {
            LogError($"Invalid name: {nameof(FirstName)} or {nameof(LastName)} is missing.");
        }
        else
        {
            Console.WriteLine($"Full Name: {FirstName} {LastName}");
        }
    }

    // Custom error logging method that highlights errors
    private void LogError(string errorMessage)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"Error: {errorMessage}");
        Console.ResetColor();
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of the Person class
        Person person = new Person();

        // Attempt to display the full name without setting the properties
        person.DisplayFullName();

        // Set the properties and display the full name again
        person.FirstName = "John";
        person.LastName = "Doe";
        person.DisplayFullName();
    }
}
Imports System

Friend Class Person
	Public Property FirstName() As String
	Public Property LastName() As String

	' Method that displays the full name of the person
	Public Sub DisplayFullName()
		If String.IsNullOrEmpty(FirstName) OrElse String.IsNullOrEmpty(LastName) Then
			LogError($"Invalid name: {NameOf(FirstName)} or {NameOf(LastName)} is missing.")
		Else
			Console.WriteLine($"Full Name: {FirstName} {LastName}")
		End If
	End Sub

	' Custom error logging method that highlights errors
	Private Sub LogError(ByVal errorMessage As String)
		Console.ForegroundColor = ConsoleColor.Red
		Console.WriteLine($"Error: {errorMessage}")
		Console.ResetColor()
	End Sub
End Class

Friend Class Program
	Shared Sub Main()
		' Create an instance of the Person class
		Dim person As New Person()

		' Attempt to display the full name without setting the properties
		person.DisplayFullName()

		' Set the properties and display the full name again
		person.FirstName = "John"
		person.LastName = "Doe"
		person.DisplayFullName()
	End Sub
End Class
$vbLabelText   $csharpLabel

Explication

  1. Nous avons une classe Person avec les propriétés FirstName et LastName et une méthode DisplayFullName qui vérifie si les deux propriétés sont définies avant d'afficher le nom complet.
  2. À l'intérieur de la méthode DisplayFullName, nous utilisons nameof(FirstName) et nameof(LastName) pour faire référence aux noms des propriétés sous forme de littéraux de chaîne. Cela améliore la lisibilité du code et garantit que si les noms des propriétés changent, à la fois la définition de la propriété et le message d'erreur correspondant sont automatiquement mis à jour lors de la compilation.
  3. La méthode LogError tire parti de nameof pour inclure dynamiquement le nom de la propriété dans le message d'erreur.
  4. Dans la méthode Main, nous créons une instance de la classe Person, essayons d'afficher le nom complet sans définir les propriétés, puis définissons les propriétés et affichons à nouveau le nom complet.

Lorsque vous exécutez ce programme, vous verrez que le message d'erreur intègre dynamiquement les noms des propriétés, offrant plus de contexte et facilitant l'identification de la propriété manquante.

Cet exemple démontre comment l'opérateur nameof améliore la maintenabilité du code en mettant à jour automatiquement les références lorsque les noms des propriétés changent et améliore les messages d'erreur avec des détails plus informatifs pendant le développement.

Présentation d'IronPDF

IronPDF for C#.NET is a PDF library from Iron Software qui peut être utilisée comme générateur et lecteur de PDF. Ici, nous présentons les fonctionnalités de base. Pour plus d'informations, consultez la documentation.

Le trait distinctif d'IronPDF est sa capacité de conversion de HTML en PDF, préservant vos mises en page et styles. Il génère des PDFs à partir de contenus web, ce qui le rend idéal pour les rapports, les factures et la documentation. Les fichiers HTML, les URLs et les chaînes HTML peuvent être convertis en PDFs sans problème.

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

IronPDF peut être installé en utilisant la console du gestionnaire de paquets NuGet ou le gestionnaire de paquets de Visual Studio.

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

C# Nameof (Comment ça fonctionne pour les développeurs): Figure 2 - Installez IronPDF en utilisant le gestionnaire de paquets NuGet en recherchant "ironpdf" dans la barre de recherche du gestionnaire de paquets NuGet.

namespace OrderBy;

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public void DisplayFullName()
    {
        if (string.IsNullOrEmpty(FirstName) || string.IsNullOrEmpty(LastName))
        {
            LogError($"Invalid name: {nameof(FirstName)} or {nameof(LastName)} is missing.");
        }
        else
        {
            Console.WriteLine($"Full Name: {FirstName} {LastName}");
        }
    }

    public void PrintPdf()
    {
        Console.WriteLine("Generating PDF using IronPDF.");
        string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {FirstName}!</h1>
<p>First Name: {FirstName}</p>
<p>Last Name: {LastName}</p>
</body>
</html>";

        // Create a new PDF document
        var pdfDocument = new ChromePdfRenderer();
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("person.pdf"); 
    }

    private void LogError(string errorMessage)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"Error: {errorMessage}");
        Console.ResetColor();
    }
}

class Program
{
    static void Main()
    {
        // Create an  instance of the Person class
        Person person = new Person();

        // Attempt to display the full name
        person.DisplayFullName();

        // Set the properties
        person.FirstName = "John";
        person.LastName = "Doe";

        // Display the full name again
        person.DisplayFullName();

        // Generate a PDF
        person.PrintPdf();
    }
}
namespace OrderBy;

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public void DisplayFullName()
    {
        if (string.IsNullOrEmpty(FirstName) || string.IsNullOrEmpty(LastName))
        {
            LogError($"Invalid name: {nameof(FirstName)} or {nameof(LastName)} is missing.");
        }
        else
        {
            Console.WriteLine($"Full Name: {FirstName} {LastName}");
        }
    }

    public void PrintPdf()
    {
        Console.WriteLine("Generating PDF using IronPDF.");
        string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {FirstName}!</h1>
<p>First Name: {FirstName}</p>
<p>Last Name: {LastName}</p>
</body>
</html>";

        // Create a new PDF document
        var pdfDocument = new ChromePdfRenderer();
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("person.pdf"); 
    }

    private void LogError(string errorMessage)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"Error: {errorMessage}");
        Console.ResetColor();
    }
}

class Program
{
    static void Main()
    {
        // Create an  instance of the Person class
        Person person = new Person();

        // Attempt to display the full name
        person.DisplayFullName();

        // Set the properties
        person.FirstName = "John";
        person.LastName = "Doe";

        // Display the full name again
        person.DisplayFullName();

        // Generate a PDF
        person.PrintPdf();
    }
}
Namespace OrderBy

	Friend Class Person
		Public Property FirstName() As String
		Public Property LastName() As String

		Public Sub DisplayFullName()
			If String.IsNullOrEmpty(FirstName) OrElse String.IsNullOrEmpty(LastName) Then
				LogError($"Invalid name: {NameOf(FirstName)} or {NameOf(LastName)} is missing.")
			Else
				Console.WriteLine($"Full Name: {FirstName} {LastName}")
			End If
		End Sub

		Public Sub PrintPdf()
			Console.WriteLine("Generating PDF using IronPDF.")
			Dim content As String = $"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {FirstName}!</h1>
<p>First Name: {FirstName}</p>
<p>Last Name: {LastName}</p>
</body>
</html>"
	ignore ignore ignore ignore ignore ignore ignore var pdfDocument = New ChromePdfRenderer()
			pdfDocument.RenderHtmlAsPdf(content).SaveAs("person.pdf")
		End Sub

		Private Sub LogError(ByVal errorMessage As String)
			Console.ForegroundColor = ConsoleColor.Red
			Console.WriteLine($"Error: {errorMessage}")
			Console.ResetColor()
		End Sub
	End Class

	Friend Class Program
		Shared Sub Main()
			' Create an  instance of the Person class
			Dim person As New Person()

			' Attempt to display the full name
			person.DisplayFullName()

			' Set the properties
			person.FirstName = "John"
			person.LastName = "Doe"

			' Display the full name again
			person.DisplayFullName()

			' Generate a PDF
			person.PrintPdf()
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel

Ici, IronPDF est utilisé pour générer un PDF à l'aide des variables locales content et pdfDocument, ce qui peut être vu dans la méthode PrintPdf.

Sortie

C# Nameof (Comment ça fonctionne pour les développeurs): Figure 3 - Sortie du programme

Génération de PDF

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

Licence (essai gratuit disponible)

Pour la licence, consultez les informations sur la licence d'essai. Cette clé doit être placée dans appsettings.json.

"IronPdf.LicenseKey": "your license key"

Fournissez votre email pour obtenir une licence d'essai.

Conclusion

L'opérateur 'nameof' de C# est devenu un incontournable pour les développeurs recherchant un code plus propre, plus sûr et plus maintenable. Sa capacité à améliorer la lisibilité du code, associée à la sécurité au moment de la compilation et au support de refactoring sans faille, en fait un outil indispensable dans la boîte à outils des développeurs C#. Au fur et à mesure que la communauté des développeurs continue d'adopter et d'exploiter l'opérateur 'nameof', il est prêt à jouer un rôle central dans la modelage de l'avenir de la programmation C#. IronPDF est un package NuGet pratique qui peut être utilisé pour générer des PDF rapidement et facilement.

Questions Fréquemment Posées

Que fait l'opérateur 'nameof' en C# ?

L'opérateur 'nameof' en C# renvoie le nom d'un élément de programme sous forme de chaîne, tel que des variables, des types ou des membres. Il améliore la lisibilité et la maintenabilité du code en éliminant les chaînes codées en dur.

Comment l'opérateur 'nameof' peut-il améliorer le refactoring de code ?

L'opérateur 'nameof' aide au refactoring de code en mettant à jour automatiquement les références lorsque les éléments sont renommés, réduisant ainsi les erreurs et améliorant l'efficacité des processus de refactorisation.

Comment l'opérateur 'nameof' est-il bénéfique pour le débogage ?

L'opérateur 'nameof' améliore le débogage en rendant les déclarations de journal et les messages d'exception plus descriptifs et moins enclins aux erreurs, fournissant dynamiquement les vrais noms des éléments du programme.

Quelle est une utilisation pratique de l'opérateur 'nameof' en C# ?

Une utilisation pratique de l'opérateur 'nameof' inclut son utilisation dans la journalisation et la gestion des exceptions pour rendre les messages plus informatifs en incluant les noms réels des variables ou des méthodes.

Comment puis-je convertir du contenu HTML en PDFs en C# ?

Vous pouvez utiliser IronPDF pour convertir du contenu HTML en PDFs en C#. IronPDF propose des méthodes pour convertir des chaînes HTML, des fichiers et des URLs en documents PDF bien formatés, idéaux pour les rapports et la documentation.

Quelles sont les étapes d'installation de la bibliothèque IronPDF ?

Pour installer IronPDF, utilisez le gestionnaire de packages NuGet dans Visual Studio en exécutant la commande dotnet add package IronPdf dans la console du gestionnaire de packages.

IronPDF peut-il gérer des conversions HTML en PDF avec des mises en page complexes ?

Oui, IronPDF est conçu pour gérer les conversions HTML en PDF tout en préservant les mises en page et styles complexes, garantissant que le PDF de sortie correspond étroitement au design HTML original.

Quels sont certains des avantages de l'utilisation d'IronPDF pour la génération de PDFs ?

IronPDF permet une génération de PDF sans faille à partir de contenu HTML, prend en charge divers types de contenu, et fournit une API facile à utiliser pour les développeurs, en faisant un outil polyvalent pour créer des documents professionnels de manière programmatique.

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