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)

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
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"
}
$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.");
}
$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);
}
$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);
}
$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.");
}
$vbLabelText   $csharpLabel

Ici, le throw new ArgumentNullException déclenche 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);
$vbLabelText   $csharpLabel

La classe d'exemple MyClass peut être une chaîne de caractères codée 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.

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.");
$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();
    }
}
$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 se référer aux noms des propriétés en tant que 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 profite 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, 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 à jour automatiquement les références lorsque les noms des propriétés changent et enrichit les messages d'erreur avec des détails plus informatifs pendant le développement.

Présentation d'IronPDF

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");
    }
}
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");
    }
}
$vbLabelText   $csharpLabel

Installation

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

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

C# Nameof (Comment ça marche pour les développeurs) : Figure 2 - Installez IronPDF à l'aide de NuGet Package Manager en recherchant 

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();
    }
}
$vbLabelText   $csharpLabel

Ici, IronPDF est utilisé pour générer un PDF en utilisant les variables locales content et pdfDocument, ce qui peut être vu dans la méthode PrintPdf.

Sortie

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

Génération de PDF

C# Nameof (Comment ça marche 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.

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
  Discutez maintenant avec l'équipe d'ingénierie
Directeur technique

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, ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me