C# Nameof (Wie es für Entwickler funktioniert)

Der 'nameof'-Operator, der in C# 6.0 eingeführt wurde, ist ein Konstrukt zur Kompilierungszeit, das die Herausforderung angeht, auf Programmelemente durch ihre Namen zu verweisen und das Laufzeitverhalten zu unterbrechen. Sein Hauptzweck ist es, die Notwendigkeit für hart kodierte Zeichenketten zu beseitigen und einen besser wartbaren und fehlerresistenten Ansatz zu bieten. In diesem Artikel werden wir uns mit dem nameof-Operator in C# beschäftigen und auch den IronPDF NuGet bibliothek zur programmgesteuerten Erzeugung von PDF-Dokumenten.

Grundlegende Syntax des 'nameof'-Operators

Die grundlegende Syntax des "nameof"-Operators ist einfach. Sie nimmt ein Element als Argument und gibt dessen Namen als Zeichenkette zurück. Betrachten Sie das folgende Beispiel:

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

In diesem Fall ist "Name des(myVariable)' ergibt die Zeichenketteneingabe "myVariable". Der Operator kann auf verschiedene Code-Elemente angewandt werden, z. B. auf Variablen, Typen, Mitglieder und mehr.

Vorteile des 'nameof'-Operators

Wartbarkeit des Codes

Einer der herausragenden Vorteile des "nameof"-Operators ist seine positive Auswirkung auf die Wartbarkeit des Codes. Anstatt Namen als Zeichenketten zu kodieren, können Entwickler "nameof" verwenden, um sicherzustellen, dass Verweise automatisch aktualisiert werden, wenn sich Namen ändern.

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

Sicherheit während der Kompilierzeit

nameof' erhöht die Sicherheit bei der Kompilierung, indem es das Risiko von Tippfehlern oder Inkonsistenzen in Namen eliminiert. Jede falsche Schreibweise oder Änderung eines Variablennamens führt zu einem Kompilierfehler, wodurch die Wahrscheinlichkeit von Laufzeitproblemen verringert wird.

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

Unterstützung beim Refactoring

Der 'nameof'-Operator lässt sich nahtlos in Refactoring-Tools integrieren und ermöglicht eine problemlose Umbenennung von Variablen, Typen oder Membern. Alle "nameof"-Verweise werden automatisch aktualisiert.

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

Verbessertes Debugging

Bei der Fehlersuche macht 'nameof' den Code informativer und lesbarer. Protokollierungsanweisungen, Ausnahmemeldungen und andere Debug-Ausgaben werden übersichtlich und kontextbezogen.

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

Hier löst die throw new ArgumentNullException nameof eine Ausnahme aus, wenn die Variable nicht deklariert ist.

Praktische Anwendungsfälle des 'nameof'-Operators

Reflexion

Bei der Arbeit mit Reflection vereinfacht der 'nameof'-Operator die Ermittlung der Namen von Typen, Eigenschaften oder Methoden, ohne dass hart kodierte Zeichenketten verwendet werden müssen.

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])

Die Beispielklasse MyClass kann eine fest codierte Zeichenkette sein, aber wir können Reflection verwenden, um den Klassennamen dynamisch zu erhalten. Der Variablentyp name enthält den Klassennamen und das Schlüsselwort nameof wird verwendet, um den Namen einer Klasseninstanz zu erhalten. Es handelt sich nicht um denselben Namen.

Protokollierung und Ausnahmebehandlung

nameof' erweist sich bei der Protokollierung von Anweisungen und Ausnahmemeldungen als unschätzbar wertvoll und macht sie lesbarer und weniger fehleranfällig.

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.")

Beispiel

In diesem Beispiel erstellen wir eine einfache Klasse, die eine Person darstellt, und verwenden den Operator nameof, um die Protokollierung und Fehlermeldungen zu verbessern.

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

Erläuterung

1. Wir haben eine Klasse Person mit den Eigenschaften FirstName und LastName und einer Methode namens DisplayFullName, die prüft, ob beide Eigenschaften gesetzt sind, bevor sie den vollständigen Namen anzeigt.

2. Innerhalb des Methodennamens DisplayFullName verwenden wir nameof(Vorname) und Name des(Nachname) um auf die Eigenschaftsnamen als Stringliterale zu verweisen. Dies verbessert die Lesbarkeit des Codes und gewährleistet, dass bei einer Änderung der Eigenschaftsnamen sowohl die Eigenschaftsdefinition als auch die entsprechende Fehlermeldung während der Kompilierung automatisch aktualisiert werden.

3. Die Methode LogError nutzt den Vorteil von nameof, um den Eigenschaftsnamen dynamisch in die Fehlermeldung aufzunehmen.

4. In der Main-Methode erstellen wir eine Instanz der Klasse Person, versuchen, den vollständigen Namen anzuzeigen, ohne die Eigenschaften zu setzen, und setzen dann die Eigenschaftsdefinition und zeigen den vollständigen Namen erneut an.

   Die öffentliche Zeichenfolge DoSomething kann mit dem Operator nameof eine Geschäftslogik ausführen.

   Wenn Sie dieses Programm ausführen, werden Sie feststellen, dass die Compiler-Fehlermeldung die Eigenschaftsnamen dynamisch einbezieht, was mehr Kontext bietet und es einfacher macht, die fehlende Eigenschaft zu identifizieren:

   

   Dieses Beispiel zeigt, wie der nameof-Operator die Wartbarkeit des Codes verbessert, indem er Verweise automatisch aktualisiert, wenn sich Eigenschaftsnamen ändern, und Fehlermeldungen während der Entwicklung durch informativere Details ergänzt.

Einführung in IronPDF

IronPDF ist eine C# PDF-Bibliothek von Iron Software das als PDF-Generator und -Reader verwendet werden kann. Hier stellen wir die grundlegenden Funktionen vor. Weitere Informationen finden Sie in der Dokumentation.

IronPDFs herausragendes Merkmal ist seine HTML zu PDF funktion, wobei Ihre Layouts und Stile erhalten bleiben. Es generiert PDFs aus Webinhalten und eignet sich daher hervorragend für Berichte, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können nahtlos in PDFs konvertiert werden.

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

Einrichtung

IronPDF kann über die NuGet-Paketmanager-Konsole oder den Visual Studio-Paketmanager installiert werden.

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

Hier wird IronPDF verwendet, um ein PDF mit den lokalen Variablen content und pdfDocument zu erzeugen, die in der Methode PrintPdf zu sehen sind.

Output

PDF-Erzeugung

Lizenzierung (kostenlose Testversion verfügbar)

IronPDF. Dieser Schlüssel muss in appsettings.json platziert werden.

"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"

Geben Sie Ihre E-Mail-Adresse an, um eine Testlizenz zu erhalten.

Schlussfolgerung

Der 'nameof'-Operator von C# ist zu einem Grundnahrungsmittel für Entwickler geworden, die sauberen, sicheren und besser wartbaren Code suchen. Seine Fähigkeit, die Lesbarkeit des Codes zu verbessern, gepaart mit Kompiliersicherheit und nahtloser Refactoring-Unterstützung, macht es zu einem unverzichtbaren Werkzeug im Werkzeugkasten des C#-Entwicklers. Da die Entwicklergemeinschaft den 'nameof'-Operator weiterhin akzeptiert und nutzt, wird er eine entscheidende Rolle bei der Gestaltung der Zukunft der C#-Programmierung spielen. IronPDF ist ein praktisches NuGet-Paket, mit dem man schnell und einfach PDFs generieren kann.