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

Conventions de dénomination le langage de programmation est un ensemble de règles et de lignes directrices que les développeurs suivent pour nommer les variables, les méthodes, les classes et d'autres entités de manière cohérente. 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. Nous allons nous pencher sur les conventions de dénomination et sur le concept deBibliothèque IronPDF plus loin dans l'article.

Vue d'ensemble des conventions d'appellation

Classes et interfaces

Les noms de classes doivent respecter la convention de dénomination 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 de méthodes utilisent également le cas Pascal. 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 du point d'entrée, static void Main()La convention est la même - utiliser le cas Pascal pour le nom de la méthode.

Propriétés

Tout comme les noms de méthodes, les noms de propriétés utilisent également le cas 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

Les variables locales et les arguments des méthodes** doivent être en majuscules. 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 de majuscules et l'argument de méthode customerName est également en majuscules.

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 des classes, comme les champs statiques, les constantes et les méthodes, suivent également des conventions de dénomination spécifiques.

Champs statiques

Pour les champs statiques, la convention de dénomination consiste à utiliser la casse camel mais avec un préfixe underscore. 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, les mots étant séparés par des traits de soulignement 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 de traitement des événements doivent décrire l'événement qu'elles traitent, 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

En utilisant 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 de 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

Veillez toujours à ce que vos définitions de méthode aient des noms significatifs et des types de retour appropriés. Le type de retour doit apparaître clairement dans 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 méthode CalculateTotalBalance est descriptif et suit la convention de dénomination Pascal Case.

Conventions d'appellation pour les C# ; constantes

En C#, les noms de constantes doivent être entièrement en majuscules, les mots étant séparés par des traits de soulignement. 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 constants sont cohérents et faciles à reconnaître dans le code.

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

C# dispose également de conventions de codage pour les sauts de ligne et les accolades. En C#, chaque ouverture brace{les doivent être sur la même ligne que l'énoncé auquel ils appartiennent, et le brace de fermeture}** Le texte doit être sur une nouvelle ligne, aligné sur l'énoncé correspondant. 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 C# moderne, on utilise 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 de caractères ou intCount pour un nombre entier)l'utilisation de l'anglais, du français et de l'allemand est déconseillée. Utilisez plutôt 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 deIronPDF dans vos projets C#, il est essentiel de maintenir un code propre et lisible en respectant les conventions de dénomination. IronPDF vous permet de générerPDF à 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 vous jeter à l'eau et explorer toutes ses capacités avec uneessai 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. Si vous êtes prêt à passer à l'étape suivante, les licences commencent à partir de 749 $.