Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Conventions de dénomination en C#
.NET AIDE

Conventions de nommage C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

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.

Vue d'ensemble des Conventions de Nommage

Classes et Interfaces

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 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
$vbLabelText   $csharpLabel

Remarquez comment le nom de la classe Customer et le nom de l'interface ICustomer suivent tous deux Pascal Case. Le préfixe I rend clair que le type ICustomer est une interface.

Méthodes

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 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
$vbLabelText   $csharpLabel

Pour 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.

Propriétés

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 DateTime DateOpened { get; set; }
public decimal Reserves { get; set; }
Public Property DateOpened() As DateTime
Public Property Reserves() As Decimal
$vbLabelText   $csharpLabel

Variables Locales et Arguments de Méthode

Les 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 void SelectCustomer(string customerName)
{
    var selectedCustomer = FindCustomer(customerName);
}
Public Sub SelectCustomer(ByVal customerName As String)
	Dim selectedCustomer = FindCustomer(customerName)
End Sub
$vbLabelText   $csharpLabel

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 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 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
$vbLabelText   $csharpLabel

Membres Statics et Champs

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

Champs Statics

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

private static int _totalCustomers;
private static int _totalCustomers;
Private Shared _totalCustomers As Integer
$vbLabelText   $csharpLabel

Constantes

Les 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 int MAX_CUSTOMERS = 100;
Public Const MAX_CUSTOMERS As Integer = 100
$vbLabelText   $csharpLabel

Gestionnaires d'événements

Les noms de méthodes de gestionnaire d'événements 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 pour les méthodes de gestionnaire d'événements incluent généralement l'objet sender et les arguments d'é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
$vbLabelText   $csharpLabel

Dans 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.

Nommage des Champs Privés et Initialiseurs d'Objet

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 string _customerName;
Private _customerName As String
$vbLabelText   $csharpLabel

Lors 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
};
var seattleCustomer = new Customer
{
    Balance = 1000,
    DateOpened = DateTime.Now
};
Dim seattleCustomer = New Customer With {
	.Balance = 1000,
	.DateOpened = DateTime.Now
}
$vbLabelText   $csharpLabel

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

Gestion des Exceptions et Méthodes

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 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
$vbLabelText   $csharpLabel

Types de Retour et Définitions de Méthodes

Assurez-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 decimal CalculateTotalBalance()
{
    return _totalCustomers * balancePerCustomer;
}
Public Function CalculateTotalBalance() As Decimal
	Return _totalCustomers * balancePerCustomer
End Function
$vbLabelText   $csharpLabel

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

Conventions de Nommage pour les Constantes C

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 double PI = 3.14159;
Public Const PI As Double = 3.14159
$vbLabelText   $csharpLabel

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

Conventions de Codage C# 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 être sur la même ligne que l'instruction à laquelle elle appartient, et l'accolade fermante } doit ê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 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
$vbLabelText   $csharpLabel

Utiliser un formatage approprié rend le code plus facile à lire et à suivre.

Éviter la Notation Hongroise

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 string CustomerName { get; set; }
public int OrderCount { get; set; }
Public Property CustomerName() As String
Public Property OrderCount() As Integer
$vbLabelText   $csharpLabel

Cette approche rend le code plus clair et plus maintenable.

Utilisation de IronPDF avec les Conventions de Nommage

Conventions de Nommage C# (Comment ça fonctionne pour les Développeurs): Figure 1 - IronPDF: La Bibliothèque PDF C#

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 en utilisant 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
$vbLabelText   $csharpLabel

En respectant ces conventions de nommage, votre code reste professionnel, organisé et facile à lire tout en utilisant IronPDF pour générer des rapports.

Conclusion

Conventions de Nommage C# (Comment ça fonctionne pour les Développeurs): Figure 2 - Page de Licences IronPDF

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 $799.

Questions Fréquemment Posées

Quelles sont les conventions de dénomination générales pour les classes et les interfaces en C#?

En C#, les classes et les interfaces doivent être nommées en utilisant la notation Pascal Case, où chaque mot commence par une lettre majuscule. Les interfaces doivent également inclure un préfixe 'I', comme 'ICustomer'.

Comment puis-je m'assurer que les noms de méthodes en C# respectent les meilleures pratiques?

Les noms de méthode en C# doivent suivre la convention Pascal Case, commençant chaque mot par une lettre majuscule. Cette convention s'applique à toutes les méthodes, y compris la méthode d'entrée Main.

Quelle est la méthode recommandée pour nommer les variables locales en C#?

Les variables locales et les arguments de méthode en C# doivent être nommés en utilisant la notation camel case, ce qui signifie que le premier mot est en minuscule et chaque mot suivant commence par une lettre majuscule.

Comment les champs statiques doivent-ils être nommés en C#?

Les champs statiques en C# doivent être nommés en utilisant la notation camel case avec un préfixe de soulignement pour les différencier des autres champs.

Quelle est la convention de dénomination pour les constantes en C#?

Les constantes en C# doivent être nommées en utilisant des lettres majuscules avec des traits de soulignement pour séparer les mots, afin d'être facilement reconnaissables.

Comment puis-je utiliser une bibliothèque tout en respectant les conventions de dénomination en C#?

Lors de l'utilisation de bibliothèques en C#, telles qu'IronPDF, maintenez un code propre et lisible en suivant les conventions de nommage. Cela inclut l'utilisation du Style Pascal pour les classes et les méthodes et le style camel pour les variables. Par exemple, vous pouvez générer des PDFs à partir de HTML en utilisant IronPDF tout en gardant des pratiques de nommage cohérentes.

Pourquoi la notation hongroise n'est-elle pas recommandée en C# ?

La notation hongroise est découragée dans le développement C# moderne car elle peut rendre le code moins lisible. Utilisez plutôt des noms significatifs qui décrivent l'objectif des variables et respectent les conventions de dénomination établies.

Comment les méthodes de gestion d'événements doivent-elles être nommées en C# ?

Les méthodes gestionnaires d'événements en C# doivent être nommées pour décrire l'événement qu'elles gèrent, en utilisant généralement le préfixe 'On' suivi du nom de l'événement. Cela aide à clarifier l'objectif de la méthode.

Quelles conventions de dénomination doivent être suivies pour les champs privés en C#?

Les champs privés en C# doivent être nommés en utilisant la notation camel case avec un préfixe de soulignement. Cela aide à les différencier des variables locales et des arguments de méthode.

Quels sont les avantages des conventions de dénomination pour les développeurs C#?

Les conventions de dénomination améliorent la lisibilité et la maintenabilité du code, ce qui le rend plus facile à comprendre et à travailler pour les développeurs. Une dénomination cohérente dans les projets C#, y compris ceux utilisant des bibliothèques comme IronPDF, garantit une base de code propre et professionnelle.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit