Wir haben Anführungszeichen im rohen Zeichenfolgenliteral durch doppelte Anführungszeichen eingefügt. Sein Hauptzweck besteht darin, die Notwendigkeit für fest codierte Zeichenfolgen zu beseitigen und einen wartungsfreundlicheren und fehlerresistenteren Ansatz zu bieten. In diesem Artikel werden wir den nameof-Operator in C# erkunden und auch die IronPDF-Bibliothek auf NuGet vorstellen, um PDF-Dokumente programmgesteuert zu erzeugen.
Die grundlegende Syntax des 'nameof'-Operators ist einfach. Er nimmt ein Element als Argument und gibt seinen Namen als Zeichenfolge zurück. Beispiel: IronPDF rendert HTML zu einem PDF und speichert es.
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 SubIn diesem Fall liefert 'nameof(myVariable)' die Zeichenfolge "myVariable". Der Operator kann auf verschiedene Code-Elemente angewendet werden, einschließlich Variablen, Typen, Mitglieder und mehr.
Einer der auffälligsten Vorteile des 'nameof'-Operators ist seine positive Auswirkung auf die Code-Wartbarkeit. Anstatt Namen als Zeichenfolgen festzukodieren, können Entwickler 'nameof' verwenden und sicherstellen, dass Referenzen 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.");
}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' verbessert die Sicherheit zur Kompilierzeit, indem das Risiko von Tippfehlern oder Inkonsistenzen in Namen eliminiert wird. Jede falsche Schreibweise oder Änderung eines Variablennamens löst einen Kompilierzeitfehler aus, was die Wahrscheinlichkeit von Laufzeitproblemen verringert.
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 SubDer 'nameof'-Operator integriert sich nahtlos mit Refactoring-Tools und bietet eine reibungslose Erfahrung beim Umbenennen von Variablen, Typen oder Mitgliedern. Alle 'nameof'-Referenzen werden automatisch aktualisiert.
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 SubWährend der Fehlersuche macht 'nameof' den Code informativer und lesbarer. Protokollzeilen, Ausnahmebotschaften und andere Debug-Ausgaben werden prägnant und inhaltlich relevanter.
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 SubHier wirft der throw new ArgumentNullException eine Ausnahme, wenn die Variable nicht deklariert ist.
Beim Arbeiten mit Reflection vereinfacht der 'nameof'-Operator das Abrufen der Namen von Typen, Eigenschaften oder Methoden, ohne fest kodierte Zeichenfolgen zu verwenden.
Type type = typeof(MyClass);
string typeName = nameof(MyClass);Dim type As Type = GetType([MyClass])
Dim typeName As String = NameOf([MyClass])Die Beispielklasse MyClass kann ein festcodierter String sein, aber wir können Reflection verwenden, um den Klassennamen dynamisch zu erhalten. Die Variable type enthält den Klassennamen, und dann wird das Schlüsselwort nameof verwendet, um den Namen einer Klasseninstanz zu erhalten. Sie sind nicht der gleiche Name.
'nameof' erweist sich bei Protokollzeilen und Ausnahmebotschaften als unschätzbar wertvoll, da sie lesbarer und weniger fehleranfällig werden.
Logger.Log($"Error: The property '{nameof(MyClass.MyProperty)}' is out of range.");Logger.Log($"Error: The property '{NameOf([MyClass].MyProperty)}' is out of range.")In diesem Beispiel erstellen wir eine einfache Klasse, die eine Person darstellt, und wir verwenden den nameof-Operator, um die Protokollierung und Fehlermeldungen zu verbessern.
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 Klasse mit FirstName und LastName Eigenschaften und eine Methode DisplayFullName, die überprüft, ob beide Eigenschaften gesetzt sind, bevor der vollständige Name angezeigt wird.DisplayFullName verwenden wir nameof(FirstName) und nameof(LastName), um auf die Eigenschaftsnamen als Zeichenfolgenliterale zu verweisen. Dies verbessert die Lesbarkeit des Codes und stellt sicher, dass sowohl die Eigenschaftsdefinition als auch die entsprechende Fehlermeldung bei einer Änderung der Eigenschaftsnamen während der Kompilierung automatisch aktualisiert werden.LogError nutzt nameof, um den Eigenschaftsnamen dynamisch in die Fehlermeldung einzubinden.Main Methode erstellen wir eine Instanz der Person Klasse, versuchen den vollständigen Namen ohne gesetzte Eigenschaften anzuzeigen, und setzen dann die Eigenschaften, um den vollständigen Namen erneut anzuzeigen.Wenn Sie dieses Programm ausführen, sehen Sie, dass die Fehlermeldung die Eigenschaftsnamen dynamisch einbezieht, was mehr Kontext bietet und es einfacher macht, zu ermitteln, welche Eigenschaft fehlt.
Dieses Beispiel zeigt, wie der nameof Operator die Wartbarkeit des Codes verbessert, indem Referenzen automatisch aktualisiert werden, wenn sich Eigenschaftsnamen ändern, und Fehlermeldungen während der Entwicklung mit informativeren Details verbessert werden.
IronPDF für C#.NET ist eine PDF-Bibliothek von Iron Software, die als PDF-Generator und -Leser verwendet werden kann. Hier stellen wir grundlegende Funktionalitäten vor. Für weitere Informationen lesen Sie die Dokumentation.
Ein herausragendes Merkmal von IronPDF ist seine HTML-zu-PDF-Konvertierungs-Fähigkeit, die Ihre Layouts und Stile beibehält. Es erzeugt PDFs aus Webinhalten und ist daher ideal für Berichte, Rechnungen und Dokumentationen geeignet. HTML-Dateien, URLs und HTML-Strings können nahtlos in PDFs umgewandelt 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");
}
}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 kann mit dem NuGet-Paketmanager-Konsole oder Visual Studio-Paketmanager installiert werden.
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 NamespaceHier wird IronPDF verwendet, um ein PDF mit den lokalen Variablen content und pdfDocument zu erzeugen, die in der PrintPdf Methode zu sehen sind.
Ausgabe
PDF-Generierung
Für lizenzrechtliche Informationen sehen Sie sich die Testlizenzinformationen an. Dieser Schlüssel muss in appsettings.json abgelegt werden.
"IronPdf.LicenseKey": "your license key"Geben Sie Ihre E-Mail für eine Testlizenz an.
Der 'nameof'-Operator von C# ist zum Standard für Entwickler geworden, die saubereren, sichereren und wartungsfreundlicheren Code suchen. Seine Fähigkeit, die Lesbarkeit des Codes zu verbessern, zusammen mit Sicherheitsvorteilen zur Kompilierzeit und nahtloser Unterstützung für Refactoring, macht ihn zu einem unverzichtbaren Werkzeug im Werkzeugkasten eines C#-Entwicklers. Da die Entwicklergemeinde weiterhin den 'nameof'-Operator annimmt und nutzt, wird er eine entscheidende Rolle bei der Gestaltung der Zukunft der C#-Programmierung spielen. IronPDF ist ein praktisches NuGet-Paket, mit dem PDFs schnell und einfach erstellt werden können.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
