Conventions d'appellation en C# (Comment ça marche pour les développeurs)

Les conventions de nommage sont un ensemble de règles et de directives que les développeurs suivent pour nommer de manière cohérente les variables, méthodes, classes et autres entités. Une dénomination cohérente améliore non seulement la lisibilité du code, mais aide également les autres développeurs à comprendre et à maintenir votre code. Ci-dessous, nous allons parcourir les conventions de nommage du C# étape par étape, en nous concentrant sur l'utilisation pratique et les exemples. Plongeons directement dans les conventions de nommage et la bibliothèque IronPDF plus tard dans l'article.

Vue d'ensemble des conventions d'appellation

Classes et interfaces

Les noms de classe doivent suivre la convention de nommage Pascal Case. Cela signifie que chaque mot du nom commence par une majuscule, sans soulignement ni espace. Les noms d'interface doivent également suivre le cas Pascal 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 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

Remarquez que le nom de la classe Customer et le nom de l'interface ICustomer suivent tous deux le cas Pascal. Le préfixe I indique clairement que le type ICustomer est une interface.

Méthodes de travail

Les noms des 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 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

Pour la méthode point d'entrée, static void Main(), la convention est la même : utilisez la casse Pascal pour le nom de la méthode.

Propriétés

Comme les noms de méthode, les noms de propriété utilisent également la casse Pascal. Les propriétés doivent être nommées de manière à décrire clairement ce qu'elles représentent :

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

Variables locales et arguments de méthode

Variables locales et arguments de méthode doivent utiliser le camel case. Cela signifie que le premier mot est en minuscule et que les mots suivants commencent par une majuscule, sans espace ni soulignement. La différence avec le cas Pascal réside dans le fait que la première lettre n'est pas en majuscule.

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

Dans cet exemple, la variable locale selectedCustomer suit la convention camel case, et l'argument de méthode customerName est également en camel case.

Arguments de méthode

Les noms des arguments des méthodes doivent être descriptifs et respecter la convention de dénomination "camel case". Cela améliore la lisibilité du code et aide les développeurs à comprendre ce que chaque argument représente.

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

Membres et champs statiques

Les membres statiques dans les classes, tels que les champs statiques, les constantes et les méthodes, suivent également des conventions de nommage spécifiques.

Champs statiques

Pour les champs statiques, la convention de nommage est d'utiliser le camel case mais avec un préfixe de soulignement. Cela les différencie des autres domaines.

private static int _totalCustomers;

private static int _totalCustomers;

Private Shared _totalCustomers As Integer

Constantes

Les constantes sont généralement nommées en utilisant toutes les lettres majuscules, avec des mots séparés par des underscores pour améliorer la lisibilité. Par exemple :

public const int MAX_CUSTOMERS = 100;

public const int MAX_CUSTOMERS = 100;

Public Const MAX_CUSTOMERS As Integer = 100

Gestionnaires d'événements

Les noms des méthodes d'événement doivent 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 des méthodes de gestion d'événements comprennent généralement l'expéditeur de l'objet et les arguments de l'événement.

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

Dans ce cas, les paramètres sont nommés sender et e. En respectant cette convention de dénomination, vos gestionnaires d'événements seront conformes aux normes de l'industrie.

Nommer les champs privés et les initiateurs d'objets

Les champs privés doivent suivre la convention camel case mais avec un préfixe de soulignement. Cela permet de les distinguer des variables locales et des arguments de méthode.

private string _customerName;

private string _customerName;

Private _customerName As String

Lors de l'utilisation des initialisateurs d'objets, 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
};

var seattleCustomer = new Customer
{
    Balance = 1000,
    DateOpened = DateTime.Now
};

Dim seattleCustomer = New Customer With {
	.Balance = 1000,
	.DateOpened = DateTime.Now
}

Dans cet exemple, les noms des propriétés Balance et DateOpened sont en Pascal Case, suivant la convention pour les propriétés.

Traitement des exceptions et méthodes

Lors de la gestion des exceptions, les noms des méthodes doivent toujours respecter les conventions Pascal Case. Les noms des 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 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

Types de retour et définitions des méthodes

Assurez-vous toujours que vos définitions de méthode portent des noms significatifs et ont des types de retour appropriés. Le type de retour doit être clair à partir de la signature de la méthode. En voici un exemple :

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

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

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

Dans cet exemple, le nom de la méthode CalculateTotalBalance est descriptif et suit la convention de nommage Pascal Case.

Conventions d'appellation pour les C# ; constantes

En C#, les noms de constantes doivent être en lettres majuscules, avec des mots séparés par des underscores. Les constantes se distinguent ainsi des autres variables. En voici un exemple :

public const double PI = 3.14159;

public const double PI = 3.14159;

Public Const PI As Double = 3.14159

Cette convention s'applique à différents types, garantissant que les noms des constantes sont cohérents et faciles à reconnaître dans le code.

C# ; Conventions de codage pour les sauts de ligne et les accolades

C# a également des conventions de codage pour les sauts de ligne et les accolades. En C#, chaque accolade ouvrante { doit se trouver sur la même ligne que l'instruction à laquelle elle appartient, et l'accolade fermante } doit se trouver sur une nouvelle ligne, alignée avec l'instruction correspondante. En voici un exemple :

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

L'utilisation d'un formatage approprié rend le code plus facile à lire et à suivre.

Éviter la notation hongroise

Dans le développement moderne en C#, la notation hongroise, où les noms de variables sont précédés par les types de données (par exemple, strName pour une chaîne de caractères ou intCount pour un entier), est déconseillée. Au lieu de cela, 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 string CustomerName { get; set; }
public int OrderCount { get; set; }

Public Property CustomerName() As String
Public Property OrderCount() As Integer

Cette approche rend le code plus clair et plus facile à maintenir.

Utilisation d'IronPDF avec les conventions de nommage

Lors de l'intégration de IronPDF dans vos projets C#, il est essentiel de maintenir un code propre et lisible en respectant les conventions de nommage. IronPDF vous permet de générer des PDFs à partir de contenu HTML dans vos applications C#. Ce faisant, il est important de respecter les conventions de dénomination pour vos classes, méthodes et variables afin de maintenir la cohérence. Exemple suivant d'une mise en œuvre simple des conventions de nommage pour améliorer la lisibilité du code à l'aide d'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();
    }
}

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

En respectant ces conventions de dénomination, votre code reste professionnel, organisé et facile à lire lorsque vous utilisez IronPDF pour générer des rapports.

Conclusion

En respectant ces conventions de dénomination C#, vous pouvez vous assurer que votre code est propre, lisible et facile à maintenir. Qu'il s'agisse de l'utilisation du Pascal Case pour les noms de classes, du camel case pour les variables locales, ou de l'utilisation d'un préfixe de soulignement pour les champs privés, ces conventions permettent d'établir une base de code cohérente.

Avec IronPDF, vous pouvez plonger et explorer toutes ses capacités avec un essai gratuit. Cette version d'essai vous permet d'expérimenter et de voir directement comment le logiciel s'intègre dans votre flux de travail. Lorsque vous êtes prêt à passer à l'étape suivante, les licences commencent à partir de $749.