Les conventions de nommage sont un ensemble de règles et de directives que les développeurs suivent pour nommer les variables, les méthodes, les classes et d'autres entités de manière cohérente. Un nommage cohérent améliore non seulement la lisibilité du code mais aide également les autres développeurs à comprendre et à maintenir votre code. Ci-dessous, nous passerons en revue les conventions de nommage C# étape par étape, en nous concentrant sur l'utilisation pratique et des exemples. Plongeons directement dans les conventions de nommage et la bibliothèque IronPDF plus tard dans l'article.
Les noms de classe doivent suivre la convention de nommage Pascal Case. Cela signifie que chaque mot dans le nom commence par une majuscule, sans tirets bas ni espaces. Les noms d'interface doivent également suivre Pascal Case mais commencer par le préfixe I. Par exemple :
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 InterfaceRemarquez comment le nom de la classe Customer et le nom de l'interface ICustomer suivent tous deux la convention Pascal Case. Le préfixe I indique clairement que le type ICustomer est une interface.
Les noms de méthodes utilisent également le Pascal Case. Chaque nom de méthode doit commencer par une majuscule, et chaque mot suivant doit également commencer par une majuscule. Voici un exemple de définitions de méthodes :
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 FunctionPour la méthode point d'entrée, static void Main(), la convention est la même : utiliser le Pascal Case pour le nom de la méthode.
Comme les noms de méthode, les noms de propriété utilisent également le Pascal Case. Les propriétés doivent être nommées pour décrire clairement ce qu'elles représentent :
public DateTime DateOpened { get; set; }
public decimal Reserves { get; set; }Public Property DateOpened() As DateTime
Public Property Reserves() As DecimalLes variables locales et les arguments de méthode doivent utiliser le camel case. Cela signifie que le premier mot est en minuscule, et les mots suivants commencent par une majuscule, sans espaces ni tirets bas. C'est différent du Pascal Case en ce que la première lettre n'est pas en majuscule.
public void SelectCustomer(string customerName)
{
var selectedCustomer = FindCustomer(customerName);
}Public Sub SelectCustomer(ByVal customerName As String)
Dim selectedCustomer = FindCustomer(customerName)
End SubDans cet exemple, la variable locale selectedCustomer suit la convention camel case, et l'argument de méthode customerName est également en camel case.
Les noms des arguments de méthode doivent être descriptifs et suivre la convention de nommage camel case. Cela améliore la lisibilité du code et aide les développeurs à comprendre ce que représente chaque 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 SubLes membres statiques dans les classes, comme les champs statiques, les constantes et les méthodes, suivent également des conventions de nommage spécifiques.
Pour les champs statiques, utilisez le camel case avec un préfixe underscore. Cela les différencie des autres champs.
private static int _totalCustomers;Private Shared _totalCustomers As IntegerLes constantes sont généralement nommées en utilisant toutes les lettres majuscules, avec les mots séparés par des tirés bas pour améliorer la lisibilité. Par exemple :
public const int MAX_CUSTOMERS = 100;Public Const MAX_CUSTOMERS As Integer = 100Les noms de méthode de gestionnaire d'événements devraient décrire l'événement qu'ils gèrent, généralement en utilisant le préfixe On suivi du nom de l'événement. Les paramètres pour les méthodes de gestionnaire d'événements incluent généralement l'objet sender et les arguments de l'événement.
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 SubDans ce cas, les paramètres sont nommés sender et e. Suivre cette convention de nommage rend vos gestionnaires d'événements cohérents avec les normes de l'industrie.
Les champs privés doivent suivre la convention camel case mais avec un préfixe underscore. Cela aide à les distinguer des variables locales et des arguments de méthode.
private string _customerName;Private _customerName As StringLors de l'utilisation des initialiseurs d'objet, vous pouvez attribuer des valeurs directement aux propriétés lors de la création d'une instance d'une classe :
var seattleCustomer = new Customer
{
Balance = 1000,
DateOpened = DateTime.Now
};Dim seattleCustomer = New Customer With {
.Balance = 1000,
.DateOpened = DateTime.Now
}Dans cet exemple, les noms de propriété Balance et DateOpened sont en Pascal Case, suivant la convention pour les propriétés.
Lors de la gestion des exceptions, les noms de méthodes doivent toujours suivre les conventions Pascal Case. Les noms de classes d'exception doivent également être en Pascal Case et se terminer par le suffixe Exception. Par exemple :
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 SubAssurez-vous toujours que vos définitions de méthode ont des noms significatifs et des types de retour appropriés. Le type de retour doit être clair d'après la signature de la méthode. Voici un exemple :
public decimal CalculateTotalBalance()
{
return _totalCustomers * balancePerCustomer;
}Public Function CalculateTotalBalance() As Decimal
Return _totalCustomers * balancePerCustomer
End FunctionDans cet exemple, le nom de méthode CalculateTotalBalance est descriptif et suit la convention de nommage Pascal Case.
En C#, les noms des constantes doivent être en majuscules, avec les mots séparés par des tirés bas. Cela permet aux constantes de se démarquer des autres variables. Voici un exemple :
public const double PI = 3.14159;Public Const PI As Double = 3.14159Cette convention s'applique à différents types, garantissant que les noms des constantes sont cohérents et faciles à reconnaître dans le code.
C# a également des conventions de codage pour les sauts de ligne et les accolades. En C#, chaque accolade ouvrante { devrait être sur la même ligne que l'instruction à laquelle elle appartient, et l'accolade fermante } devrait être sur une nouvelle ligne, alignée avec l'instruction correspondante. Voici un exemple :
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 SubUtiliser un formatage approprié rend le code plus facile à lire et à suivre.
Dans le développement moderne C#, la notation hongroise, où les noms de variables sont préfixés par des types de données (par exemple, strName pour une chaîne ou intCount pour un entier), est découragée. Au lieu, utilisez des noms significatifs qui décrivent l'objectif de la variable plutôt que son type de données :
public string CustomerName { get; set; }
public int OrderCount { get; set; }Public Property CustomerName() As String
Public Property OrderCount() As IntegerCette approche rend le code plus clair et plus maintenable.
Lors de l'intégration de IronPDF dans vos projets C#, il est essentiel de maintenir un code propre et lisible en suivant les conventions de nommage. IronPDF vous permet de générer des PDF à partir de contenu HTML au sein de vos applications C#. En procédant ainsi, il est important de suivre les conventions de nommage pour vos classes, méthodes et variables pour maintenir la cohérence. Ci-dessous se trouve un exemple d'une mise en œuvre simple de conventions de nommage pour améliorer la lisibilité du code avec IronPDF tout en respectant ces conventions de nommage :
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 ModuleEn respectant ces conventions de nommage, votre code reste professionnel, organisé et facile à lire tout avec IronPDF pour générer des rapports.
En suivant ces conventions de nommage C#, vous pouvez vous assurer que votre code est propre, lisible et facile à maintenir. Que ce soit en utilisant le Pascal Case pour les noms de classe, le camel case pour les variables locales, ou en utilisant un préfixe underscore pour les champs privés, ces conventions aident à établir une base de code cohérente.
Avec IronPDF, vous pouvez plonger et explorer toutes ses capacités avec un essai gratuit. Cet essai vous permet d'expérimenter et de voir par vous-même comment cela s'intègre bien à votre workflow. Lorsque vous êtes prêt à passer à l'étape suivante, les licences commencent à partir de simplement $999.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
