Konwencje nazewnictwa to zbiór zasad i wytycznych, których programiści przestrzegają, aby nadawać zmienne, metody, klasy i inne elementy w spójny sposób. Spójna nazewnictwo nie tylko poprawia czytelność kodu, ale także pomaga innym programistom zrozumieć i utrzymywać Twój kod. Poniżej omówimy krok po kroku konwencje nazewnictwa w języku C#, skupiając się na praktycznym zastosowaniu i przykładach. W dalszej części artykułu omówimy konwencje nazewnictwa oraz bibliotekę IronPDF.
Nazwy klas powinny być zgodne z konwencją nazewniczą Pascal Case. Oznacza to, że każde słowo w nazwie zaczyna się wielką literą, bez znaków podkreślenia ani spacji. Nazwy interfejsów powinny również być zgodne z konwencją Pascal Case, ale zaczynać się od przedrostka I. Na przykład:
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 InterfaceZauważ, jak nazwa klasy Customer i nazwa interfejsu ICustomer obie stosują Pascal Case. Prefix I czyni jasnym, że typ ICustomer jest interfejsem.
Nazwy metod również pisane są wielkimi literami (Pascal Case). Każda nazwa metody powinna zaczynać się wielką literą, a każde kolejne słowo również powinno zaczynać się wielką literą. Oto przykład definicji metod:
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 FunctionW przypadku metody punktu wejścia, static void Main(), obowiązuje ta sama konwencja — nazwa metody powinna być zapisana w formacie Pascal Case.
Podobnie jak nazwy metod, nazwy właściwości również są zapisywane w stylu Pascal Case. Nazwy właściwości powinny jasno opisywać to, co reprezentują:
public DateTime DateOpened { get; set; }
public decimal Reserves { get; set; }Public Property DateOpened() As DateTime
Public Property Reserves() As DecimalW 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 Sub SelectCustomer(ByVal customerName As String)
Dim selectedCustomer = FindCustomer(customerName)
End SubW tym przykładzie zmienna lokalna selectedCustomer stosuje konwencję camel case, a argument metody customerName również jest w camel case.
Nazwy argumentów metod powinny być opisowe i zgodne z konwencją nazewniczą camel case. Poprawia to czytelność kodu i pomaga programistom zrozumieć, co oznacza każdy argument.
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 SubElementy statyczne w klasach, takie jak pola statyczne, stałe i metody, również podlegają określonym konwencjom nazewniczym.
W przypadku pól statycznych obowiązuje konwencja nazewnictwa polegająca na stosowaniu wielkich liter na początku każdego słowa (camel case), ale z prefiksem w postaci podkreślenia. To odróżnia je od innych dziedzin.
private static int _totalCustomers;Private Shared _totalCustomers As IntegerNazwy stałych są zazwyczaj zapisywane wielkimi literami, a słowa oddzielane są znakami podkreślenia w celu poprawy czytelności. Na przykład:
public const int MAX_CUSTOMERS = 100;Public Const MAX_CUSTOMERS As Integer = 100Nazwy metod obsługi zdarzeń powinny opisywać zdarzenie, które obsługują, zwykle za pomocą preifksu On, a następnie nazwy zdarzenia. Parametry dla metod obsługi zdarzeń zazwyczaj zawierają obiekt sender oraz argumenty zdarzenia.
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 SubW tym przypadku parametry są nazwane sender i e. Przestrzeganie tej konwencji nazewnictwa sprawia, że procedury obsługi zdarzeń są zgodne ze standardami branżowymi.
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 _customerName As StringKorzystają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
};Dim seattleCustomer = New Customer With {
.Balance = 1000,
.DateOpened = DateTime.Now
}W tym przykładzie nazwy właściwości Balance i DateOpened są w Pascal Case, zgodnie z konwencją dla właściwości.
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 Sub ProcessTransaction()
Try
' Transaction logic
Catch ex As InvalidOperationException
' Handle exception
End Try
End SubZawsze upewnij się, że definicje metod mają sensowne nazwy i odpowiednie typy zwracanych wartości. Typ zwracanej wartości powinien być jasny na podstawie sygnatury metody. Oto przykład:
public decimal CalculateTotalBalance()
{
return _totalCustomers * balancePerCustomer;
}Public Function CalculateTotalBalance() As Decimal
Return _totalCustomers * balancePerCustomer
End FunctionW tym przykładzie nazwa metody CalculateTotalBalance jest opisowa i stosuje konwencję nazewniczą Pascal Case.
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 PI As Double = 3.14159Konwencja ta ma zastosowanie w różnych typach, zapewniając spójność nazw stałych i ich łatwą rozpoznawalność w kodzie.
W języku C# obowiązują również konwencje kodowania dotyczące znaków końca linii i nawiasów klamrowych. W C# każda otwierająca klamra { powinna być na tej samej linii co instrukcja, do której należy, a zamykająca klamra } powinna być na nowej linii, wyrównana z odpowiadającą jej instrukcją. Oto przykład:
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 SubZastosowanie odpowiedniego formatowania sprawia, że kod jest łatwiejszy do odczytania i zrozumienia.
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 Property CustomerName() As String
Public Property OrderCount() As IntegerTakie podejście sprawia, że kod jest bardziej przejrzysty i łatwiejszy w utrzymaniu.
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();
}
}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 ModuleDzięki przestrzeganiu tych konwencji nazewniczych kod pozostaje profesjonalny, uporządkowany i łatwy do odczytania podczas korzystania z IronPDF do generowania raportów.
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, aby zrobić kolejny krok, licencje zaczynają się od zaledwie $999.
Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
