Convention de codage C# : Norme de codage en C#

Conventions de codage sont un ensemble de lignes directrices pour l’écriture de code cohérent, lisible et compréhensible. Ils sont aussi parfois appelés conventions de programmation, guides de style, ou norme de codage. Ces conventions couvrent divers aspects du code, tels que les conventions de dénomination, l’indentation, les commentaires et la mise en forme. En suivant ces conventions, les développeurs peuvent rapidement comprendre la structure et l’objectif du code, ce qui facilite le débogage et la maintenance du code. De plus, les conventions garantissent que le code est cohérent au sein d’une équipe ou d’une organisation, ce qui peut améliorer la collaboration et la communication entre les développeurs.

Le terme «code propre» fait référence à un style de programmation qui privilégie également la maintenabilité et l’évolutivité en suivant des principes tels que la clarté, la simplicité, la cohérence et la modularité. Un code propre est important pour les principaux développeurs et les autres développeurs qui le liront et le maintiendront à l’avenir. L’écrire exige de la discipline et une attention aux détails, mais les avantages en valent la peine. Il peut améliorer la vitesse et l’efficacité du développement, réduire les bogues et les erreurs et rendre la base de code plus évolutive et maintenable.

L’écriture de code propre et le respect des conventions sont importants pour chaque programmeur, mais surtout pour les développeurs C#, car le langage C# a une syntaxe stricte et des fonctionnalités orientées objet qui peuvent rendre difficile l’écriture de code lisible et efficace. C # est un langage de programmation moderne orienté objet développé par Microsoft et lancé pour la première fois en 2002. Il est basé sur le langage de programmation C et est principalement conçu pour créer des applications et des jeux de bureau Windows, des applications Web et des applications mobiles. Cet article passera en revue les conseils les plus utiles pour écrire du code propre en C #, ainsi que quelques exemples de codage afin que vous puissiez mieux saisir l’idée de ce qui est expliqué.

Meilleures pratiques pour écrire du code propre

Puisque l’importance d’écrire du code propre et de suivre les conventions de codage a déjà été expliquée, examinons maintenant quelques conseils sur la façon d’écrire réellement un tel code, avec une explication détaillée et un exemple de codage pour chacun de ces conseils.

Suivez les règles de formatage

Garder le code bien structuré et organisé est essentiel pour avoir un projet réussi et éviter tout futur casse-tête. Par conséquent, chaque équipe de développement est censée proposer un guide de style spécifique qui spécifie les exigences de formatage du code qu’elles écrivent. Ainsi, la meilleure façon de formater le code et d’obtenir une meilleure lisibilité est de suivre ce guide de style que votre équipe a défini, ainsi que de suivre certaines conventions de mise en page communément acceptées. L’utilisation d’un bon éditeur de code ou de l’IDE C# facilitera le processus d’écriture, car il gère le formatage pour vous.

Voyons maintenant des exemples de la façon dont le code formaté vs non formaté ressemble à :

# Bad practice
class Car
{static void Main(string[] args)
    {Console.WriteLine("This is a car class");
    }
}

# Good practice
class Car
{
    static void Main(string[] args)
    {
        Console.WriteLine("This is a car class!");
    }
}

Donnez des noms significatifs

Lorsque vous nommez des variables ou des méthodes, assurez-vous toujours de donner un nom significatif qui a du sens et qui est facile à retenir. Bien que cela ne semble pas être un gros problème maintenant, il y aura beaucoup de confusion et de complications inutiles une fois que le projet grandira et deviendra plus complexe. Un bon nom est concis et aide les développeurs à comprendre l’utilisation et le contexte de cette méthode ou variable spécifique. Penser aux noms de variables peut prendre du temps, mais c’est absolument nécessaire car cela vous fera gagner beaucoup de temps à l’avenir.

Voici un exemple :

# Bad practice
string yyyymmdd;

# Good practice
string currentDateString;

Utiliser la notation Camel Case

La notation en cas de chameau est lorsque la lettre initiale du premier mot de la variable est en minuscule et la première lettre de chaque mot suivant est en majuscule. La casse camel doit être utilisée pour nommer les variables locales, les arguments de méthode, les paramètres et les champs. N’oubliez pas non plus que, lorsque vous nommez des champs internes ou privés, ils doivent être précédés de _.

Vous trouverez ci-dessous deux exemples d’utilisation de l’étui camel :

# Bad practice
int Sum;
private DateTime Date;

# Good practice
int sum;
private DateTime _date;

Utiliser la notation de cas Pascal

La notation de casse Pascal est lorsque toutes les premières lettres de chaque mot sont en majuscules. La casse Pascal doit être utilisée pour nommer les classes, les enregistrements, les structures et les membres publics des types (méthodes, champs, propriétés). De plus, ce type de casse doit être utilisé lors de la dénomination des interfaces, et le nom doit être précédé d’un « I ».

Vous trouverez ci-dessous deux exemples d’utilisation du cas pascal :

# Bad practice
public class program
public interface queue
public void print()
    {
        Console.WriteLine("This is a print method!");
    }

# Good practice
public class Program
public interface IQueue
public void Print()
    {
        Console.WriteLine("This is a print method!");

Utilisez les « && » et « || » Les opérateurs

Utilisez « && » et « || » au lieu de « & » et « | » lors des comparaisons pour éviter les exceptions et améliorer les performances en contournant les comparaisons inutiles. Lorsque l’opérateur « && » est utilisé, la première condition est d’abord vérifiée. S’il s’avère falsela deuxième condition n’est même pas vérifiée car l’opérateur « && » (ET) ne renvoie que true si les deux conditions sont true. Par conséquent, le résultat sera toujours false, quelle que soit la sortie de la seconde condition. Cependant, lorsque l’opérateur « & » est utilisé, les deux critères sont toujours vérifiés, ce qui peut diminuer les performances de l’application. Il en va de même pour le « || » Opérateur (OU).

Comprenons mieux cela en examinant un scénario où l’opérateur « & » lèverait une exception, mais pas le « && », reconnaissant ainsi l’importance de ce dernier :

# Bad practice 
# This will throw an exception
int x = 0;
int y = 15;

if ((x != 0) & (y / x < 0))
{
  # Do something
}

# Good practice
int x = 0;
int y = 15;

if ((x != 0) && (y / x < 0))
{
  # Do something
}

Suivez les conventions de commentaires

Mettre des commentaires sur le code que vous avez écrit est parfois indispensable pour le rendre compréhensible et lisible. Cependant, gardez à l’esprit que l’ajout de trop de commentaires peut le rendre désordonné, alors essayez d’écrire du code explicite chaque fois que possible et évitez de jeter des commentaires aléatoires dans le programme ici et là. Lorsque vous avez besoin de mettre un commentaire, assurez-vous de suivre les conventions énoncées ci-dessous, afin d’éviter d’écrire des commentaires mauvais et inutiles.

Voici quelques lignes directrices sur les commentaires :

Les commentaires doivent commencer par une lettre majuscule.
Les commentaires doivent se terminer par un point.
Les commentaires doivent figurer sur une ligne distincte.
Les commentaires ne doivent pas être entourés de blocs d’astérisques formatés.
Il doit y avoir un espace entre le délimiteur de commentaire (//) et le texte du commentaire, comme illustré dans l’exemple ci-dessous.

Pour mieux comprendre quand un commentaire peut être inutile et quand il est absolument utile, jetez un œil à ces exemples :

# Bad practice
class Car
{
    static void Main(string[] args)
    {
        powerLevel = 90;
        Console.WriteLine("Car class."); // print "Car class"
    }
}

# Good practice
class Car
{
    static void Main(string[] args)
    {
      // Output the name of the class.
        Console.WriteLine("Car class."); 
    }
}

Écrire du code réutilisable

L’écriture de code réutilisable est importante car avoir moins de lignes de code rendra le projet plus efficace. Qu’entend-on par code réutilisable ? Eh bien, cela signifie qu’il ne devrait pas y avoir plusieurs copies de la même fonction dans différentes classes, ou qu’il ne devrait pas y avoir les mêmes morceaux de code dans différentes parties du code. Plutôt que cela, ce code répétitif doit être encapsulé dans une fonction, et si cette fonction est utilisée dans plusieurs classes, elle doit être créée une fois, puis référencée partout où cela est nécessaire. De cette façon, la fonction sera réutilisable, et en plus, si des changements sont nécessaires, ils seront appliqués à un seul endroit, au lieu de passer par toutes les classes qui ont cette fonction.

Évitez les nombres magiques et les chaînes magiques

Tout d’abord, que sont les nombres magiques et les chaînes magiques ? Ce sont des chaînes/nombres qui sont spécifiés dans le code et qui affectent directement le comportement du programme. Pour éviter de telles variables, il faut éviter les chaînes ou les nombres codés en dur dans l’application, et il y a plusieurs raisons pour lesquelles c’est une bonne idée. Tout d’abord, le suivi de ces variables peut devenir très difficile à mesure que l’application devient plus complexe. Deuxièmement, ces chaînes peuvent être connectées à de nombreux types de références externes, telles que des noms de fichiers ou des chemins de fichiers, ce qui peut entraîner un problème une fois que le nom ou l’emplacement du fichier change. De plus, les variables magiques se dupliquent souvent, ce qui les rend sujettes aux erreurs en raison de leur incapacité à être automatiquement mises à jour.

L’extrait de code ci-dessous est un exemple de comment éviter les nombres magiques en déclarant une constante :

# Bad practice
if (age < 18)
{
    # Do something;
}

# Good practice
public const int legalAge = 18;
if (age < legalAge)
{
    # Do something;
}

N’oubliez pas la puissance de l’opérateur ternaire

L’opérateur conditionnel ternaire, également connu sous le nom d’opérateur conditionnel » ? : « , évalue une expression booléenne pour déterminer si elle correspond à true ou false puis renvoie le résultat de l’une des deux expressions. De cette façon, au lieu d’écrire plusieurs lignes de code, nous pouvons écrire une seule ligne qui fait exactement la même chose. Cependant, gardez à l’esprit que l’opérateur ternaire ne doit être appliqué que pour les instructions if simples, car il peut rapidement devenir très désordonné si la condition et la logique sont plutôt complexes.

Voici un exemple pratique de la façon dont cela fonctionne :

# Bad practice
public string CheckAge(int age)
{
    if (age < 18)
    {
        return "The person has less than 18 years.";
    }
    else
    {
        return "The...