C#-Namenskonventionen (Wie es für Entwickler funktioniert)

Benennungskonventionen sind eine Reihe von Regeln und Richtlinien, die Entwickler befolgen, um Variablen, Methoden, Klassen und andere Einheiten einheitlich zu benennen. Eine konsistente Namensgebung verbessert nicht nur die Lesbarkeit des Codes, sondern hilft auch anderen Entwicklern, Ihren Code zu verstehen und zu pflegen. Im Folgenden werden wir die C#-Namenskonventionen Schritt für Schritt durchgehen und uns dabei auf die praktische Anwendung und Beispiele konzentrieren. Lassen Sie uns gleich über Namenskonventionen und dieIronPDF-Bibliothek weiter unten in dem Artikel.

Übersicht über die Namenskonventionen

Klassen und Schnittstellen

Klassennamen sollten der Pascal Case-Namenskonvention folgen. Das bedeutet, dass jedes Wort im Namen mit einem Großbuchstaben beginnt, ohne Unterstriche oder Leerzeichen. Die Schnittstellennamen sollten ebenfalls dem Pascal Case folgen, aber 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

Beachten Sie, dass der Klassenname Customer und der Schnittstellenname ICustomer beide dem Pascal Case folgen. Das Präfix I verdeutlicht, dass es sich beim Typ ICustomer um eine Schnittstelle handelt.

Methoden

Methodennamen verwenden ebenfalls den Pascal Case. Jeder Methodenname sollte mit einem Großbuchstaben beginnen, und jedes folgende Wort sollte ebenfalls mit einem Großbuchstaben beginnen. Hier ist ein Beispiel für eine Methodendefinition:

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

Für die Einstiegsmethode, static void Main(), die Konvention ist die gleiche - verwenden Sie Pascal Case für den Methodennamen.

Eigenschaften

Wie bei Methodennamen wird auch bei Eigenschaftsnamen Pascal Case verwendet. Eigenschaften sollten so benannt werden, dass sie klar beschreiben, was sie darstellen:

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

Lokale Variablen und Methodenargumente

Lokale Variablen und Methodenargumente sollten in Kleinbuchstaben geschrieben werden. Das bedeutet, dass das erste Wort in Kleinbuchstaben geschrieben wird und die nachfolgenden Wörter mit einem Großbuchstaben beginnen, ohne Leerzeichen oder Unterstriche. Der Unterschied zu Pascal's Case besteht darin, 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

In diesem Beispiel folgt die lokale Variable selectedCustomer der Konvention der Groß- und Kleinschreibung, und das Methodenargument customerName ist ebenfalls in Groß- und Kleinschreibung.

Argumente für die Methode

Die Namen der Methodenargumente sollten beschreibend sein und der Konvention der Groß- und Kleinschreibung folgen. Dies verbessert die Lesbarkeit des Codes und hilft den Entwicklern zu verstehen, wofür jedes Argument steht.

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

Statische Mitglieder und Felder

Statische Elemente in Klassen, wie statische Felder, Konstanten und Methoden, folgen ebenfalls bestimmten Namenskonventionen.

Statische Felder

Für statische Felder ist die Namenskonvention die Verwendung von Kleinbuchstaben, aber mit einem Unterstrich-Präfix. Dadurch unterscheiden sie sich von anderen Bereichen.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

Konstanten

Konstanten werden in der Regel mit Großbuchstaben benannt, wobei Wörter zur besseren Lesbarkeit durch Unterstriche getrennt werden. Zum Beispiel:

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

Public Const MAX_CUSTOMERS As Integer = 100

Ereignishandler

Event-Handler-Methodennamen sollten das Ereignis beschreiben, das sie behandeln, normalerweise durch die Verwendung des Präfixes On, gefolgt von dem Ereignisnamen. Die Parameter für Ereignisbehandlungsmethoden umfassen in der Regel den Objektabsender 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

In diesem Fall sind die Parameter Absender und e genannt. Wenn Sie diese Namenskonvention befolgen, sind Ihre Event-Handler mit den Industriestandards konsistent.

Benennung von privaten Feldern und Objektinitialisierern

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

private string _customerName;

private string _customerName;

Private _customerName As String

Bei der Verwendung von Objektinitialisierern können Sie bei der Erstellung einer Instanz einer Klasse den Eigenschaften direkt Werte 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
}

In diesem Beispiel sind die Eigenschaftsnamen Balance und DateOpened in Pascal Case, entsprechend der Konvention für Eigenschaften.

Ausnahmebehandlung und Methoden

Bei der Behandlung von Ausnahmen sollten die Methodennamen weiterhin den Pascal Case Konventionen folgen. Die Namen der Ausnahmeklassen 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

Rückgabetypen und Methodendefinitionen

Achten Sie immer darauf, dass Ihre Methodendefinitionen aussagekräftige Namen und geeignete Rückgabetypen haben. Der Rückgabetyp sollte aus der Signatur der Methode 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

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

Benennungskonventionen für C# Konstanten

In C# sollten Konstantennamen ausschließlich aus Großbuchstaben bestehen, wobei die Wörter durch Unterstriche getrennt werden. Dadurch heben sich Konstanten von anderen Variablen ab. Hier ist ein Beispiel:

public const double PI = 3.14159;

public const double PI = 3.14159;

Public Const PI As Double = 3.14159

Diese Konvention gilt für verschiedene Typen und stellt sicher, dass die konstanten Namen konsistent und im Code leicht zu erkennen sind.

C# Kodierungskonventionen für Zeilenumbrüche und Klammern

C# hat auch Kodierungskonventionen für Zeilenumbrüche und Klammern. In C# wird jede öffnende Klammer{ sollte in der gleichen Zeile stehen wie die dazugehörige Anweisung und die abschließende Klammer} Der Text sollte in einer neuen Zeile stehen, ausgerichtet an der entsprechenden Anweisung. 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

Durch die richtige Formatierung ist der Code leichter zu lesen und zu verstehen.

Vermeidung der ungarischen Notation

In der modernen C#-Entwicklung wird die Ungarische Notation verwendet, bei der den Variablennamen Datentypen vorangestellt werden(z. B. strName für eine Zeichenkette oder intCount für eine ganze Zahl), wird abgeraten. Verwenden Sie stattdessen aussagekräftige Namen, die den Zweck der Variablen und nicht ihren Datentyp beschreiben:

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

Auf diese Weise wird der Code klarer und besser wartbar.

Verwendung von IronPDF mit Benennungskonventionen

Bei der Integration vonIronPDF in Ihren C#-Projekten ist es wichtig, sauberen, lesbaren Code zu erhalten, indem Sie Namenskonventionen einhalten. IronPDF ermöglicht Ihnen die Erstellung vonPDFs aus HTML-Inhalten innerhalb Ihrer C#-Anwendungen. Dabei ist es wichtig, dass Sie die Namenskonventionen für Ihre Klassen, Methoden und Variablen einhalten, um die Konsistenz zu wahren. Nachfolgend ein Beispiel für eine einfache Implementierung von Namenskonventionen zur Verbesserung der Lesbarkeit von Code unter Verwendung von IronPDF und unter Einhaltung dieser Namenskonventionen:

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

Wenn Sie sich an diese Namenskonventionen halten, bleibt Ihr Code professionell, übersichtlich und leicht lesbar, während Sie IronPDF für die Erstellung von Berichten verwenden.

Schlussfolgerung

Wenn Sie diese C#-Namenskonventionen befolgen, können Sie sicherstellen, dass Ihr Code sauber, lesbar und einfach zu pflegen ist. Ob es sich um die Verwendung von Pascal Case für Klassennamen, Camel Case für lokale Variablen oder die Verwendung eines Unterstrich-Präfixes für private Felder handelt, diese Konventionen helfen, eine konsistente Codebasis zu schaffen.

Mit IronPDF können Sie sofort loslegen und all seine Möglichkeiten mit einerkostenloser Test. Mit dieser Testversion können Sie experimentieren und aus erster Hand sehen, wie gut sie sich in Ihren Arbeitsablauf integrieren lässt. Wenn Sie bereit sind, den nächsten Schritt zu gehen, beginnen die Lizenzen bei nur $749.