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

Übersicht über die Namenskonventionen

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

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

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 Mitglieder in Klassen, wie statische Felder, Konstanten und Methoden, folgen ebenfalls spezifischen Benennungskonventionen.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

Public Const MAX_CUSTOMERS As Integer = 100

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

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

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
}

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 decimal CalculateTotalBalance()
{
    return _totalCustomers * balancePerCustomer;
}

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

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

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

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

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

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

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.