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.
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"
}Shared Sub Main()
' Declare a string variable
Dim myVariable As String = NameOf(myVariable)
Console.WriteLine(myVariable) ' Output: "myVariable"
End SubDans 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.
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.");
}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'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);
}Shared Sub Main()
' Compile-time error if 'myVariable' is misspelled
Dim myVariable As String
Dim variableName As String = NameOf(myVariable)
Console.WriteLine(variableName)
End SubL'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);
}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 SubPendant 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.");
}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 SubIci, le throw new ArgumentNullException génère une exception si la variable n'est pas déclarée.
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);Dim type As Type = GetType([MyClass])
Dim typeName As String = NameOf([MyClass])La classe d'exemple MyClass peut être une chaîne en dur, mais nous pouvons utiliser la réflexion pour obtenir le nom de la classe dynamiquement. La variable type contient 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.
'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.")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();
}
}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 ClassPerson 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.DisplayFullName, nous utilisons nameof(FirstName) et nameof(LastName) pour référer aux noms des propriétés comme 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.LogError tire parti de nameof pour inclure dynamiquement le nom de la propriété dans le message d'erreur.Main, nous créons une instance de la classe Person, tentons 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 automatiquement à jour les références lorsque les noms des propriétés changent et en enrichissant les messages d'erreur avec des détails plus informatifs pendant le développement.
IronPDF pour C#.NET est une bibliothèque PDF de 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");
}
}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 ClassIronPDF peut être installé en utilisant la console du Package Manager NuGet ou le Package Manager de Visual Studio.
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 NamespaceIci, IronPDF est utilisé pour générer un PDF en utilisant les variables locales content et pdfDocument, qui peuvent être vues dans la méthode PrintPdf.
Sortie
Génération de PDF
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.
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.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
