Quelle convention de dénomination utiliser pour les paramètres de fonction C #

Dans certains cas, un nom transmis dans Parameter sera converti en un nouveau type, mais le nom de l'objet Passed doit rester similaire. Pour le cas des attributs de classe, nous pouvons utiliser cet opérateur, mais qu'en est-il de la variable locale dans les fonctions. Quelle convention de codage est largement utilisée.

exemple,

void MyFunc(BaseClass myPara)
{
  DerivedClass _mypara = (BaseClass)myPara;
}

ou au contraire

void MyFunc(BaseClass _myPara)
{
  DerivedClass mypara = (BaseClass)_myPara;
}

ou toute autre conventionl

Préfixer des paramètres ou des variables locales avec un trait de soulignement n'est pas très idiomatique en C #, il n'est pas très facile à lire et n'est pas souvent utilisé (bien qu'il soit légal, vous pouvez donc le faire si vous le souhaitez).

Le meilleur nom pour le paramètre et la variable est un nom descriptif. Vous devez penser pourquoi vous changez de type, quelle est la raison de la distribution. Ensuite, vous devriez pouvoir trouver 2 noms différents. Par exemple, si vous avez passé une "personne" et que vous l'avez convertie en "client", vous pouvez peut-être utiliser la personne et / ou le client dans les noms de variable.

Si vous ne pouvez vraiment pas penser à 2 noms différents, j'utiliserais "as" dans le nom ( il y avait une question sur ce site il y a quelques jours à ce sujet ). Par exemple, vous utiliseriez "myParaAsDerived" pour la variable locale.

Si possible, je n'utiliserais pas cela, je réfléchirais sérieusement au problème que vous résolvez et aux noms significatifs qui pourraient être utilisés, mais si tout le reste échoue, cela est assez lisible.

Tout d'abord en utilisant

void MyFunc(BaseClass _myPara)
{
} 

Est clairement faux! Comme beaucoup de normes de codage c # utilisent un préfixe «_» sur tous les noms de champs ! Votre code doit être facile à comprendre par les autres programmeurs, de sorte que le code ne doit pas être écrit de manière à induire en erreur de nombreux programmeurs C #.

Étant donné tous les avantages des petites méthodes, je ne vois personnellement pas la nécessité d'une convention de dénomination pour séparer les variables locales des paramètres. Si vos méthodes ont tellement de paramètres et de variables locales que vous ne pouvez pas savoir ce qui se passe sans convention de dénomination, vous avez de plus gros problèmes. (Ceci est bien couvert dans le Clean Code Book , un livre Java mais je l'ai toujours trouvé très utile en tant que programmeur C #)

Si vous voulez les préfixer avec quelque chose, vous devez utiliser le p_paramètre: en général, je suppose que vous ennuieriez probablement beaucoup de gens si vous faisiez cela. MAIS soyez cohérent, ne le faites pas au même endroit simplement parce que vous avez besoin de deux noms différents pour les variables que vous voulez donner le même nom.

Une bonne règle générale avec un nom variable va comme;

• Si vous n'avez qu'un seul type d'objet, nommez-le par sa fonction:

  var builder = new PizzaBuilder();

• Si vous en avez plusieurs, nommez-les par leur fonction et leur spécialité:

  var pizzaBuilder = new PizzaBuilder();
  var milkShakeBuilder = new MilkShakeBuilder();

Les conventions d'appellation C # vous permettront:

• Utilisation de PascalCasing pour les méthodes, les propriétés publiques et les noms de classe
• Utilisation d'IPascalCasing (notez le I au début) pour les noms d'interface
• Utilisation de camelCasing pour les paramètres de méthode et les variables locales
• Utilisation de _underscoredCamelCasing pour les champs privés à l'échelle de la classe

Et restez à l'écart de la notation hongroise. C'est inutile et n'adhère pas aux conventions C #.

Il peut être inutile de souligner la dénomination des variables car nous avons le mot-clé "this" pour faire spécifiquement référence aux variables de niveau classe. Si vous souhaitez en savoir plus sur les conventions de dénomination des variables auprès des experts, je vous suggère de jeter un coup d'œil au fameux article intitulé "Règles d'Ottinger pour le nommage des variables et des classes" par Tim Ottinger, un article soutenu par le mentor en codage propre Robert C. Martin .

Ottinger déclare que votre code doit rester aussi lisible que possible, comme une prose bien écrite, alors ...

public void Function(string p_Parameter1, string p_Parameter2)

... serait plus lisible comme ...

public void Function(string parameter1, string parameter2)

... où paramètre1 et 2 sont des noms descriptifs pour les variables correspondantes.

Voici le lien, qui vaut vraiment le détour: Lien

Je crois au suffixe des paramètres: chaîne s_, int i_, etc.

Je pense également que les noms de parmes doivent être aussi courts et génériques que possible.

Maintenant pour les raisons:

• Dans la fonction, vous ne voulez en aucun cas modifier le paramètre, si vous avez besoin d'une version modifiée, créez une nouvelle variable pour la coller. La dénomination des paramètres avec un suffixe vous assurera de ne pas leur affecter si vous payez attention.
• Des exceptions à cette règle surviennent lorsque le parm est ref ou out. Bien que j'utilise toujours le suffixe sur ceux-ci.
• Pourquoi des noms génériques courts? Vous devez documenter votre fonction afin de savoir ce qu'est réellement s_ au sens descriptif. Donc, avec cela à l'écart, l'utilisation de génériques courts est pratique lorsque vous créez des groupes de fonctions similaires ou que vous coupez un corps de fonction pour le transporter vers une autre fonction comme point de départ de la modification.
• Le véritable avantage des noms génériques est que vous n'avez pas à vous rappeler ce que vous avez appelé ce paramètre dans la plupart des cas. Vous savez que vous obtenez une chaîne, donc c'est s_, etc. et vous n'avez pas à vous demander si c'est 'filename' ou était-ce 'filepath' ou était-ce 'fullpath', c'est la seule chaîne donc son 's_'.

Tout a des compromis, et si vous utilisez quelque chose ou non dépendra beaucoup de la façon dont il s'intègre dans votre style actuel.