C# Nomof (Comment ça marche pour les développeurs)

L'opérateur " nameof ", introduit dans C# 6.0, est une construction à la compilation conçue pour relever le défi de se référer à des éléments de programme par leur nom et de briser silencieusement le comportement à l'exécution. Son objectif principal est d'éliminer le besoin de chaînes codées en dur, offrant ainsi une approche plus facile à maintenir et plus résistante aux erreurs. Dans cet article, nous explorerons l'opérateur nameof en C# et présenterons également l'opérateurBibliothèque IronPDF sur NuGet pour générer des documents PDF par programme.

Syntaxe de base de l'opérateur "nameof

La syntaxe fondamentale de l'opérateur "nameof" est simple. Il prend un élément comme argument et renvoie son nom sous forme de chaîne de caractères. Prenons l'exemple suivant :

static void Main()
{
 //string name
  string myVariable = nameof(myVariable);
}

static void Main()
{
 //string name
  string myVariable = nameof(myVariable);
}

Shared Sub Main()
 'string name
  Dim myVariable As String = NameOf(myVariable)
End Sub

Dans ce cas, "nameof(maVariable)' produit la chaîne de caractères "maVariable". L'opérateur peut être appliqué à divers éléments de code, y compris les variables, les types, les membres, etc.

Avantages de l'opérateur "nameof

Maintenabilité du code

L'un des principaux avantages de l'opérateur "nameof" est son impact positif sur la maintenabilité du code. Au lieu de coder les noms en dur sous forme de chaînes de caractères, les développeurs peuvent utiliser "nameof", ce qui garantit que les références sont automatiquement mises à jour 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

Sécurité au moment de la compilation

l'option "nameof" renforce la sécurité à la compilation en éliminant le risque de fautes de frappe ou d'incohérences dans les noms. Toute erreur d'orthographe ou de modification d'un nom de variable déclenche une erreur de compilation, ce qui réduit les risques de problèmes d'exécution.

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

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

Shared Sub Main()
' Compile-time error if 'myVariable' is misspelled
Dim myVariable As String = NameOf(myVariabell)
End Sub

Aide au remaniement

L'opérateur "nameof" s'intègre parfaitement aux outils de refactorisation, ce qui permet de renommer sans problème les variables, les types ou les membres. Toutes les références au "nom de" sont mises à jour automatiquement.

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

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

Shared Sub Main()
' Before renaming local variable 'myVariable' to 'newVariable'
Dim myVariable As String = NameOf(myVariable)
' After renaming local variable  'myVariable' to 'newVariable'
Dim newVariable As String = NameOf(newVariable)
End Sub

Débogage amélioré

Lors du débogage, "nameof" rend le code plus informatif et plus lisible. Les instructions de journalisation, les messages d'exception et les autres sorties de débogage deviennent concis et adaptés au contexte.

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

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

Cas pratiques d'utilisation de l'opérateur "nameof" (nom)

Réflexion

Lorsque l'on travaille avec la réflexion, l'opérateur "nameof" simplifie l'obtention des noms des types, des propriétés ou des 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])

La classe d'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 de manière dynamique. Le type de nom de la variable contient le nom de la classe et le mot-clé nameof est utilisé pour obtenir le nom d'une instance de la classe. Il ne s'agit pas du même nom.

Journalisation et gestion des exceptions

'nameof' s'avère inestimable dans la journalisation des déclarations et des messages d'exception, les rendant plus lisibles et moins sujets 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.")

Exemple

Dans cet exemple, nous allons créer une classe simple représentant une personne, et nous utiliserons l'opérateur nameof pour améliorer la journalisation et les messages d'erreur.

using System;
class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }    
    //method name
    public void DisplayFullName()
    {
        if (string.IsNullOrEmpty(FirstName) 
 string.IsNullOrEmpty(LastName))
        {
            LogError($"Invalid name: {nameof(FirstName)} or {nameof(LastName)} is missing."); // display string
        }
        else
        {
            Console.WriteLine($"Full Name: {FirstName} {LastName}");
        }
    }
    public string DoSomething()
{
}
    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"; // string
        person.LastName = "Doe"; // string
        // Display the full name string again
        person.DisplayFullName();
    }
}

using System;
class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }    
    //method name
    public void DisplayFullName()
    {
        if (string.IsNullOrEmpty(FirstName) 
 string.IsNullOrEmpty(LastName))
        {
            LogError($"Invalid name: {nameof(FirstName)} or {nameof(LastName)} is missing."); // display string
        }
        else
        {
            Console.WriteLine($"Full Name: {FirstName} {LastName}");
        }
    }
    public string DoSomething()
{
}
    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"; // string
        person.LastName = "Doe"; // string
        // Display the full name string again
        person.DisplayFullName();
    }
}

Imports System
Friend Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	'method name
	Public Sub DisplayFullName()
		If String.IsNullOrEmpty(FirstName) String.IsNullOrEmpty(LastName) Then
			LogError($"Invalid name: {NameOf(FirstName)} or {NameOf(LastName)} is missing.") ' display string
		Else
			Console.WriteLine($"Full Name: {FirstName} {LastName}")
		End If
	End Sub
	Public Function DoSomething() As String
	End Function
	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" ' string
		person.LastName = "Doe" ' string
		' Display the full name string again
		person.DisplayFullName()
	End Sub
End Class

Explication

1. Nous disposons d'une classe Personne avec les propriétés Prénom et Nom et d'une méthode nommée AfficherNomplet qui vérifie si les deux propriétés sont définies avant d'afficher le nom complet.

2. Dans le nom de la méthode DisplayFullName, nous utilisons nameof(Prénom) et le nom de(Nom de famille) pour faire référence aux noms des propriétés sous forme de chaînes de caractères. Cela améliore la lisibilité du code et garantit que si les noms des propriétés changent, 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 Personne, nous essayons d'afficher le nom complet sans définir les propriétés, puis nous définissons les propriétés et affichons à nouveau le nom complet.

   La chaîne publique DoSomething peut exécuter une certaine logique commerciale à l'aide de l'opérateur nameof.

   Lorsque vous exécuterez ce programme, vous verrez que le message d'erreur du compilateur incorpore dynamiquement les noms des propriétés, fournissant plus de contexte et facilitant l'identification de la propriété manquante :

   

   Cet exemple 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 améliore 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 deIron Software qui peut être utilisé comme générateur et lecteur de PDF. Nous présentons ici les fonctionnalités de base. Pour plus d'informations, reportez-vous à la documentation.

La caractéristique la plus remarquable d'IronPDF est sonConversion de HTML en PDF en préservant vos mises en page et vos styles. Il génère des PDF à partir de contenus web, ce qui est idéal pour les rapports, les factures et la documentation. Les fichiers HTML, les URL et les chaînes HTML peuvent être convertis en PDF de manière transparente.

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

IronPDF peut être installé à l'aide de la console du gestionnaire de paquets NuGet ou du gestionnaire de paquets Visual Studio.

dotnet add package IronPdf

dotnet add package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf

namespace OrderBy;
using System;
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>First 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"; // string literal
        person.LastName = "Doe"; // string literal
        // Display the full name again
        person.DisplayFullName();
    }
}

namespace OrderBy;
using System;
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>First 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"; // string literal
        person.LastName = "Doe"; // string literal
        // Display the full name again
        person.DisplayFullName();
    }
}

Imports System

Namespace OrderBy
	Friend Class Person
		Public Property FirstName() As String
		Public Property LastName() As String
		Public Sub DisplayFullName()
			If String.IsNullOrEmpty(FirstName) 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>First 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" ' string literal
			person.LastName = "Doe" ' string literal
			' Display the full name again
			person.DisplayFullName()
		End Sub
	End Class
End Namespace

Ici, IronPDF est utilisé pour générer un PDF à l'aide des variables locales content et pdfDocument, comme on peut le voir dans la méthode PrintPdf.

Sortie

**Génération PDF

Licence (essai gratuit disponible)

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

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"

Indiquez votre adresse électronique pour obtenir une licence d'essai.

Conclusion

L'opérateur "nameof" de C# est devenu un incontournable pour les développeurs à la recherche d'un code plus propre, plus sûr et plus facile à maintenir. Sa capacité à améliorer la lisibilité du code, associée à la sécurité au moment de la compilation et à la prise en charge du refactoring en continu, en fait un outil indispensable dans la boîte à outils du développeur C#. Alors que la communauté des développeurs continue d'adopter et d'exploiter l'opérateur "nameof", celui-ci est sur le point de jouer un rôle essentiel dans 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.