Benennungskonventionen sind eine Reihe von Regeln und Richtlinien, denen Entwickler folgen, um Variablen, Methoden, Klassen und andere Entitäten konsistent zu benennen. Konsistente Benennungen verbessern nicht nur die Lesbarkeit des Codes, sondern helfen auch anderen Entwicklern, Ihren Code zu verstehen und zu warten. Im Folgenden gehen wir die C#-Benennungskonventionen Schritt für Schritt durch und konzentrieren uns auf praktische Anwendungen und Beispiele. Lassen Sie uns direkt in die Benennungskonventionen eintauchen und später im Artikel die IronPDF-Bibliothek besprechen.

Übersicht über die Namenskonventionen

Klassen und Schnittstellen

Klassennamen sollten der Pascal-Case-Benennungskonvention folgen. Das bedeutet, dass jedes Wort im Namen mit einem Großbuchstaben beginnt, ohne Unterstriche oder Leerzeichen. Schnittstellennamen sollten auch Pascal Case folgen, jedoch mit dem Präfix I beginnen. Zum Beispiel:

public class Customer
{
    public decimal Balance { get; set; }
}

public interface ICustomer
{
    decimal GetBalance();
}

public class Customer
{
    public decimal Balance { get; set; }
}

public interface ICustomer
{
    decimal GetBalance();
}

Public Class Customer
	Public Property Balance() As Decimal
End Class

Public Interface ICustomer
	Function GetBalance() As Decimal
End Interface

Public Class Customer
	Public Property Balance() As Decimal
End Class

Public Interface ICustomer
	Function GetBalance() As Decimal
End Interface

Beachten Sie, wie der Klassenname Customer und der Schnittstellenname ICustomer beide dem Pascal Case folgen. Das Präfix I macht deutlich, dass der Typ ICustomer eine Schnittstelle ist.

Methoden

Methodennamen verwenden ebenfalls das Pascal Case. Jeder Methodenname sollte mit einem Großbuchstaben beginnen und jedes nachfolgende Wort sollte ebenfalls mit einem Großbuchstaben beginnen. Hier ist ein Beispiel für Methodendefinitionen:

public decimal CalculateInterest(decimal principal, decimal rate)
{
    return principal * rate;
}

public decimal CalculateInterest(decimal principal, decimal rate)
{
    return principal * rate;
}

Public Function CalculateInterest(ByVal principal As Decimal, ByVal rate As Decimal) As Decimal
	Return principal * rate
End Function

Public Function CalculateInterest(ByVal principal As Decimal, ByVal rate As Decimal) As Decimal
	Return principal * rate
End Function

Für die Einstiegspunktmethode static void Main() gilt dieselbe Konvention – verwenden Sie Pascal Case für den Methodennamen.

Eigenschaften

Wie Methodennamen verwenden auch Eigenschaftennamen Pascal Case. Eigenschaften sollten so benannt werden, dass sie klar beschreiben, was sie repräsentieren:

public DateTime DateOpened { get; set; }
public decimal Reserves { get; set; }

public DateTime DateOpened { get; set; }
public decimal Reserves { get; set; }

Public Property DateOpened() As DateTime
Public Property Reserves() As Decimal

Public Property DateOpened() As DateTime
Public Property Reserves() As Decimal

Lokale Variablen und Methodenargumente

Lokale Variablen und Methodenargumente sollten Camel Case verwenden. Das bedeutet, dass das erste Wort in Kleinbuchstaben ist und nachfolgende Wörter mit einem Großbuchstaben beginnen, ohne Leerzeichen oder Unterstriche. Dies unterscheidet sich von Pascal Case dadurch, dass der erste Buchstabe nicht großgeschrieben wird.

public void SelectCustomer(string customerName)
{
    var selectedCustomer = FindCustomer(customerName);
}

public void SelectCustomer(string customerName)
{
    var selectedCustomer = FindCustomer(customerName);
}

Public Sub SelectCustomer(ByVal customerName As String)
	Dim selectedCustomer = FindCustomer(customerName)
End Sub

Public Sub SelectCustomer(ByVal customerName As String)
	Dim selectedCustomer = FindCustomer(customerName)
End Sub

In diesem Beispiel folgt die lokale Variable selectedCustomer der Camel Case-Konvention, und das Methode-Argument customerName ist ebenfalls im Camel Case.

Methoden-Argumente

Die Namen von Methodenargumenten sollten beschreibend sein und der Camel-Case-Benennungsregel folgen. Das verbessert die Lesbarkeit des Codes und hilft Entwicklern zu verstehen, was jedes Argument darstellt.

public void AddCustomer(string customerName, DateTime dateOpened)
{
    // Add customer logic
}

public void AddCustomer(string customerName, DateTime dateOpened)
{
    // Add customer logic
}

Public Sub AddCustomer(ByVal customerName As String, ByVal dateOpened As DateTime)
	' Add customer logic
End Sub

Public Sub AddCustomer(ByVal customerName As String, ByVal dateOpened As DateTime)
	' Add customer logic
End Sub

Statische Mitglieder und Felder

Statische Mitglieder in Klassen, wie statische Felder, Konstanten und Methoden, folgen ebenfalls spezifischen Benennungskonventionen.

Statische Felder

Für statische Felder ist die Benennungskonvention, Camel Case zu verwenden, jedoch mit einem Unterstrich-Präfix. Dies unterscheidet sie von anderen Feldern.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

Private Shared _totalCustomers As Integer

Konstanten

Konstanten werden typischerweise mit allen Großbuchstaben benannt, wobei Wörter durch Unterstriche getrennt werden, um die Lesbarkeit zu verbessern. Zum Beispiel:

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

Public Const MAX_CUSTOMERS As Integer = 100

Public Const MAX_CUSTOMERS As Integer = 100

Ereignishandler

Event-Handler-Methodennamen sollten das Ereignis beschreiben, das sie behandeln, üblicherweise durch Verwendung des Präfixes On gefolgt vom Ereignisnamen. Die Parameter für Event-Handler-Methoden beinhalten typischerweise das Objekt sender und die Ereignisargumente.

private void OnCustomerAdded(object sender, EventArgs e)
{
    // Event handling logic
}

private void OnCustomerAdded(object sender, EventArgs e)
{
    // Event handling logic
}

Private Sub OnCustomerAdded(ByVal sender As Object, ByVal e As EventArgs)
	' Event handling logic
End Sub

Private Sub OnCustomerAdded(ByVal sender As Object, ByVal e As EventArgs)
	' Event handling logic
End Sub

In diesem Fall sind die Parameter benannt sender und e. Durch die Einhaltung dieser Benennungskonventionen werden Ihre Ereignishandler konsistent mit den Branchenstandards.

Benennung privater Felder und Objektinitialisierer

Private Felder sollten der Camel Case-Konvention folgen, jedoch mit einem Unterstrich-Präfix. Dies hilft, sie von lokalen Variablen und Methodenargumenten zu unterscheiden.

private string _customerName;

private string _customerName;

Private _customerName As String

Private _customerName As String

Beim Verwenden von Objektinitialisierern können Sie beim Erstellen einer Instanz einer Klasse direkt Werte zu Eigenschaften zuweisen:

var seattleCustomer = new Customer
{
    Balance = 1000,
    DateOpened = DateTime.Now
};

var seattleCustomer = new Customer
{
    Balance = 1000,
    DateOpened = DateTime.Now
};

Dim seattleCustomer = New Customer With {
	.Balance = 1000,
	.DateOpened = DateTime.Now
}

Dim seattleCustomer = New Customer With {
	.Balance = 1000,
	.DateOpened = DateTime.Now
}

In diesem Beispiel sind die Eigenschaftsnamen Balance und DateOpened im Pascal Case, gemäß der Konvention für Eigenschaften.

Ausnahmebehandlung und Methoden

Bei der Ausnahmebehandlung sollten Methodennamen weiterhin die Pascal Case-Konventionen befolgen. Ausnahmeklassennamen sollten ebenfalls in Pascal Case sein und mit dem Suffix Exception enden. Zum Beispiel:

public void ProcessTransaction()
{
    try
    {
        // Transaction logic
    }
    catch (InvalidOperationException ex)
    {
        // Handle exception
    }
}

public void ProcessTransaction()
{
    try
    {
        // Transaction logic
    }
    catch (InvalidOperationException ex)
    {
        // Handle exception
    }
}

Public Sub ProcessTransaction()
	Try
		' Transaction logic
	Catch ex As InvalidOperationException
		' Handle exception
	End Try
End Sub

Public Sub ProcessTransaction()
	Try
		' Transaction logic
	Catch ex As InvalidOperationException
		' Handle exception
	End Try
End Sub

Rückgabetypen und Methodendefinitionen

Stellen Sie immer sicher, dass Ihre Methodendefinitionen aussagekräftige Namen und geeignete Rückgabetypen haben. Der Rückgabetyp sollte aus der Methodensignatur klar hervorgehen. Hier ist ein Beispiel:

public decimal CalculateTotalBalance()
{
    return _totalCustomers * balancePerCustomer;
}

public decimal CalculateTotalBalance()
{
    return _totalCustomers * balancePerCustomer;
}

Public Function CalculateTotalBalance() As Decimal
	Return _totalCustomers * balancePerCustomer
End Function

Public Function CalculateTotalBalance() As Decimal
	Return _totalCustomers * balancePerCustomer
End Function

In diesem Beispiel ist der Methodenname CalculateTotalBalance beschreibend und folgt der Pascal Case Namenskonvention.

Namenskonventionen für C# Konstanten

In C# sollten Konstantennamen aus allen Großbuchstaben bestehen, wobei Wörter durch Unterstriche getrennt sind. Dies hilft, Konstanten von anderen Variablen abzuheben. Hier ist ein Beispiel:

public const double PI = 3.14159;

public const double PI = 3.14159;

Public Const PI As Double = 3.14159

Public Const PI As Double = 3.14159

Diese Konvention gilt für verschiedene Typen und stellt sicher, dass Konstantennamen konsistent und leicht erkennbar im Code sind.

C# Coding Conventions für Zeilenumbrüche und Klammern

C# hat auch Kodierungskonventionen für Zeilenumbrüche und Klammern. In C# sollte jede öffnende Klammer { in derselben Zeile wie die Anweisung stehen, zu der sie gehört, und die schließende Klammer } sollte in einer neuen Zeile, ausgerichtet mit der entsprechenden Anweisung, stehen. Hier ist ein Beispiel:

public void AddCustomer(string customerName)
{
    if (!string.IsNullOrEmpty(customerName))
    {
        _customerName = customerName;
    }
}

public void AddCustomer(string customerName)
{
    if (!string.IsNullOrEmpty(customerName))
    {
        _customerName = customerName;
    }
}

Public Sub AddCustomer(ByVal customerName As String)
	If Not String.IsNullOrEmpty(customerName) Then
		_customerName = customerName
	End If
End Sub

Public Sub AddCustomer(ByVal customerName As String)
	If Not String.IsNullOrEmpty(customerName) Then
		_customerName = customerName
	End If
End Sub

Durch die richtige Formatierung wird der Code leichter lesbar und nachvollziehbar.

Vermeidung der ungarischen Notation

In der modernen C#-Entwicklung wird die ungarische Notation, bei der Variablennamen mit Datentypen (z.B. strName für einen String oder intCount für einen Integer) vorangestellt werden, entmutigt. Verwenden Sie stattdessen aussagekräftige Namen, die den Zweck der Variablen beschreiben, anstatt den Datentyp:

public string CustomerName { get; set; }
public int OrderCount { get; set; }

public string CustomerName { get; set; }
public int OrderCount { get; set; }

Public Property CustomerName() As String
Public Property OrderCount() As Integer

Public Property CustomerName() As String
Public Property OrderCount() As Integer

Dieser Ansatz macht den Code klarer und wartbarer.

Verwendung von IronPDF mit Namenskonventionen

Wenn Sie IronPDF in Ihre C#-Projekte integrieren, ist es wichtig, einen sauberen, lesbaren Code durch die Einhaltung von Benennungskonventionen aufrechtzuerhalten. IronPDF ermöglicht es Ihnen, PDFs aus HTML-Inhalten innerhalb Ihrer C#-Anwendungen zu generieren. Dabei ist es wichtig, Benennungskonventionen für Ihre Klassen, Methoden und Variablen zu befolgen, um Konsistenz zu gewährleisten. Im Folgenden finden Sie ein Beispiel für eine einfache Implementierung von Benennungskonventionen zur Verbesserung der Lesbarkeit des Codes mit IronPDF, während diese Benennungskonventionen eingehalten werden:

using IronPdf;

public class PdfReportGenerator
{
    private readonly string _htmlContent;
    private readonly string _filePath;

    public PdfReportGenerator(string htmlContent, string filePath)
    {
        _htmlContent = htmlContent;
        _filePath = filePath;
    }

    public void GenerateReport()
    {
        var pdfRenderer = new ChromePdfRenderer();
        PdfDocument pdfDocument = pdfRenderer.RenderHtmlAsPdf(_htmlContent);
        pdfDocument.SaveAs(_filePath);
    }
}

public static class Program
{
    public static void Main()
    {
        var htmlContent = "<h1>Monthly Report</h1><p>Generated using IronPDF.</p>";
        var filePath = @"C:\Reports\MonthlyReport.pdf";
        PdfReportGenerator reportGenerator = new PdfReportGenerator(htmlContent, filePath);
        reportGenerator.GenerateReport();
    }
}

using IronPdf;

public class PdfReportGenerator
{
    private readonly string _htmlContent;
    private readonly string _filePath;

    public PdfReportGenerator(string htmlContent, string filePath)
    {
        _htmlContent = htmlContent;
        _filePath = filePath;
    }

    public void GenerateReport()
    {
        var pdfRenderer = new ChromePdfRenderer();
        PdfDocument pdfDocument = pdfRenderer.RenderHtmlAsPdf(_htmlContent);
        pdfDocument.SaveAs(_filePath);
    }
}

public static class Program
{
    public static void Main()
    {
        var htmlContent = "<h1>Monthly Report</h1><p>Generated using IronPDF.</p>";
        var filePath = @"C:\Reports\MonthlyReport.pdf";
        PdfReportGenerator reportGenerator = new PdfReportGenerator(htmlContent, filePath);
        reportGenerator.GenerateReport();
    }
}

Imports IronPdf

Public Class PdfReportGenerator
	Private ReadOnly _htmlContent As String
	Private ReadOnly _filePath As String

	Public Sub New(ByVal htmlContent As String, ByVal filePath As String)
		_htmlContent = htmlContent
		_filePath = filePath
	End Sub

	Public Sub GenerateReport()
		Dim pdfRenderer = New ChromePdfRenderer()
		Dim pdfDocument As PdfDocument = pdfRenderer.RenderHtmlAsPdf(_htmlContent)
		pdfDocument.SaveAs(_filePath)
	End Sub
End Class

Public Module Program
	Public Sub Main()
		Dim htmlContent = "<h1>Monthly Report</h1><p>Generated using IronPDF.</p>"
		Dim filePath = "C:\Reports\MonthlyReport.pdf"
		Dim reportGenerator As New PdfReportGenerator(htmlContent, filePath)
		reportGenerator.GenerateReport()
	End Sub
End Module

Imports IronPdf

Public Class PdfReportGenerator
	Private ReadOnly _htmlContent As String
	Private ReadOnly _filePath As String

	Public Sub New(ByVal htmlContent As String, ByVal filePath As String)
		_htmlContent = htmlContent
		_filePath = filePath
	End Sub

	Public Sub GenerateReport()
		Dim pdfRenderer = New ChromePdfRenderer()
		Dim pdfDocument As PdfDocument = pdfRenderer.RenderHtmlAsPdf(_htmlContent)
		pdfDocument.SaveAs(_filePath)
	End Sub
End Class

Public Module Program
	Public Sub Main()
		Dim htmlContent = "<h1>Monthly Report</h1><p>Generated using IronPDF.</p>"
		Dim filePath = "C:\Reports\MonthlyReport.pdf"
		Dim reportGenerator As New PdfReportGenerator(htmlContent, filePath)
		reportGenerator.GenerateReport()
	End Sub
End Module

Durch die Einhaltung dieser Benennungskonventionen bleibt Ihr Code professionell, organisiert und leicht lesbar, während Sie IronPDF zur Berichtsgenerierung verwenden.

Abschluss

Indem Sie diesen C#-Benennungskonventionen folgen, stellen Sie sicher, dass Ihr Code sauber, lesbar und leicht wartbar ist. Egal, ob Sie für Klassennamen Pascal Case, für lokale Variablen Camel Case oder für private Felder ein Unterstrich-Präfix verwenden, diese Konventionen tragen dazu bei, einen konsistenten Codebestand zu etablieren.

Mit IronPDF können Sie alle seine Funktionen mit einer kostenlosen Testversion erkunden. Diese Testversion ermöglicht es Ihnen, zu experimentieren und aus erster Hand zu sehen, wie gut es sich in Ihren Workflow integriert. Wenn Sie bereit sind, den nächsten Schritt zu tun, beginnen die Lizenzen bereits bei $999.