C# Konwencje nazewnictwa (Jak to dziala dla programistow)

Przegląd konwencji nazewniczych

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

Zmienne lokalne i argumenty metod

W zmiennych lokalnych i argumentach metod należy stosować pisownię wielką literą. Oznacza to, że pierwsze słowo jest pisane małą literą, a kolejne słowa zaczynają się wielką literą, bez spacji ani znaków podkreślenia. Różni się to od pisowni Pascal Case tym, że pierwsza litera nie jest wielka.

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

W tym przykładzie zmienna lokalna selectedCustomer jest zgodna z konwencją camel case, a argument metody customerName również jest zapisany w stylu 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

Członkowie statyczni i pola

Elementy statyczne w klasach, takie jak pola statyczne, stałe i metody, również podlegają określonym konwencjom nazewniczym.

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

Nazywanie pól prywatnych i inicjalizatorów obiektów

Pola prywatne powinny być zapisane zgodnie z konwencją camel case, ale z prefiksem w postaci podkreślenia. Pomaga to odróżnić je od zmiennych lokalnych i argumentów metod.

private string _customerName;

private string _customerName;

Private _customerName As String

Korzystając z inicjalizatorów obiektów, można przypisywać wartości bezpośrednio do właściwości podczas tworzenia instancji klasy:

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
}

W tym przykładzie nazwy właściwości Balance i DateOpened są zapisane w stylu Pascal Case, zgodnie z konwencją dotyczącą właściwości.

Obsługa wyjątków i metody

W przypadku obsługi wyjątków nazwy metod powinny nadal być zgodne z konwencjami Pascal Case. Nazwy klas wyjątków powinny być również zapisane w stylu Pascal Case i kończyć się przyrostkiem Exception. Na przykład:

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

Konwencje nazewnictwa dla stałych w języku C

W języku C# nazwy stałych powinny być zapisane wielkimi literami, a słowa oddzielone znakami podkreślenia. Dzięki temu stałe wyróżniają się na tle innych zmiennych. Oto przykład:

public const double PI = 3.14159;

public const double PI = 3.14159;

Public Const PI As Double = 3.14159

Konwencja ta ma zastosowanie w różnych typach, zapewniając spójność nazw stałych i ich łatwą rozpoznawalność w kodzie.

Konwencje kodowania w języku C# dotyczące znaków końca linii i nawiasów

W języku C# obowiązują również konwencje kodowania dotyczące znaków końca linii i nawiasów klamrowych. W języku C# każdy nawias otwierający { powinien znajdować się w tym samym wierszu co instrukcja, do której należy, a nawias zamykający } powinien znajdować się w nowym wierszu, wyrównanym z odpowiednią instrukcją. Oto przykład:

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

Zastosowanie odpowiedniego formatowania sprawia, że kod jest łatwiejszy do odczytania i zrozumienia.

Unikanie notacji węgierskiej

We współczesnym programowaniu w języku C# odradza się stosowanie notacji węgierskiej, w której nazwy zmiennych są poprzedzone typami danych (np. strName dla ciągu znaków lub intCount dla liczby całkowitej). Zamiast tego używaj sensownych nazw, które opisują przeznaczenie zmiennej, a nie jej typ danych:

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

Takie podejście sprawia, że kod jest bardziej przejrzysty i łatwiejszy w utrzymaniu.

Korzystanie z IronPDF z zachowaniem konwencji nazewniczych

Podczas integracji IronPDF z projektami C# ważne jest, aby zachować przejrzysty i czytelny kod, przestrzegając konwencji nazewniczych. IronPDF pozwala generować pliki PDF z treści HTML w aplikacjach napisanych w języku C#. W tym celu ważne jest przestrzeganie konwencji nazewnictwa klas, metod i zmiennych, aby zachować spójność. Poniżej znajduje się przykład prostego wdrożenia konwencji nazewniczych w celu poprawy czytelności kodu przy użyciu IronPDF, przy jednoczesnym przestrzeganiu tych konwencji:

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

Dzięki przestrzeganiu tych konwencji nazewniczych kod pozostaje profesjonalny, uporządkowany i łatwy do odczytania podczas korzystania z IronPDF do generowania raportów.

Wnioski

Przestrzegając tych konwencji nazewnictwa w języku C#, możesz zapewnić, że Twój kod będzie przejrzysty, czytelny i łatwy w utrzymaniu. Niezależnie od tego, czy chodzi o stosowanie wielkich liter na początku nazw klas (Pascal Case), wielkich liter na początku nazw zmiennych lokalnych (camel case), czy też przedrostka podkreślenia dla pól prywatnych, konwencje te pomagają stworzyć spójną bazę kodu.

Dzięki IronPDF możesz od razu zacząć korzystać z wszystkich jego możliwości w ramach bezpłatnej wersji próbnej. Ta wersja próbna pozwala na eksperymentowanie i sprawdzenie na własnej skórze, jak dobrze integruje się ona z Twoim przepływem pracy. Gdy będziesz gotowy na kolejny krok, ceny licencji zaczynają się już od $799.