Convention de nommage C # pour les constantes?

private const int THE_ANSWER = 42;

ou

private const int theAnswer = 42;

Personnellement, je pense qu'avec les IDE modernes, nous devrions utiliser camelCase car ALL_CAPS a l'air étrange. Qu'est-ce que tu penses?

La convention de dénomination et de capitalisation recommandée consiste à utiliser P ascal C asing pour les constantes (Microsoft a un outil nommé StyleCop qui documente toutes les conventions préférées et peut vérifier la conformité de votre source - même si elle est un peu trop anale pour les goûts de nombreuses personnes) . par exemple

private const int TheAnswer = 42;

La convention de capitalisation Pascal est également documentée dans les Framework Design Guidelines de Microsoft .

Visuellement, Upper Case est la voie à suivre. C'est tellement reconnaissable de cette façon. Par souci d'unicité et ne laissant aucune chance de deviner, je vote pour UPPER_CASE!

const int THE_ANSWER = 42;

Remarque : Les majuscules seront utiles lorsque les constantes doivent être utilisées dans le même fichier en haut de la page et à des fins d'intellisense; cependant, s'ils devaient être déplacés vers une classe indépendante, l'utilisation de majuscules ne ferait pas beaucoup de différence, par exemple:

public static class Constant
{
    public static readonly int Cons1 = 1;
    public static readonly int coNs2 = 2;
    public static readonly int cOns3 = 3;
    public static readonly int CONS4 = 4;
}

// Call constants from anywhere
// Since the class has a unique and recognizable name, Upper Case might lose its charm
private void DoSomething(){
var getCons1 = Constant.Cons1;
var getCons2 = Constant.coNs2;
var getCons3 = Constant.cOns3;
var getCons4 = Constant.CONS4;
 }

En fait, c'est

private const int TheAnswer = 42;

Au moins si vous regardez la bibliothèque .NET, quelle IMO est le meilleur moyen de décider des conventions de dénomination - de sorte que votre code ne semble pas à sa place.

J'utilise toujours les majuscules pour les valeurs const, mais c'est plus par habitude que pour une raison particulière.

Bien sûr, il est facile de voir immédiatement que quelque chose est un const. La question que je me pose est la suivante: avons-nous vraiment besoin de ces informations? Cela nous aide-t-il de quelque manière que ce soit à éviter les erreurs? Si j'attribue une valeur à la const, le compilateur me dira que j'ai fait quelque chose de stupide.

Ma conclusion: allez avec le boîtier de chameau. Peut-être que je changerai aussi mon style ;-)

Éditer:

Ce quelque chose qui sent le hongrois n'est pas vraiment un argument valable, OMI. La question devrait toujours être: est-ce que ça aide ou ça fait mal?

Il y a des cas où le hongrois aide. Pas beaucoup de nos jours, mais ils existent toujours.

Premièrement, la notation hongroise consiste à utiliser un préfixe pour afficher le type de données d'un paramètre ou l'utilisation prévue. Conventions de dénomination de Microsoft pour dire non à la notation hongroise http://en.wikipedia.org/wiki/Hungarian_notation http://msdn.microsoft.com/en-us/library/ms229045.aspx

L'utilisation de UPPERCASE n'est pas encouragée comme indiqué ici: Pascal Case est la convention acceptable et SCREAMING CAPS. http://en.wikibooks.org/wiki/C_Sharp_Programming/Naming

Microsoft indique également ici que UPPERCASE peut être utilisé s'il est fait pour correspondre au schéma existant. http://msdn.microsoft.com/en-us/library/x2dbyw72.aspx

Cela résume à peu près tout.

Dans son article Constants (Guide de programmation C #) , Microsoft donne l'exemple suivant:

class Calendar3
{
    const int months = 12;
    const int weeks = 52;
    const int days = 365;

    const double daysPerWeek = (double) days / (double) weeks;
    const double daysPerMonth = (double) days / (double) months;
}

Ainsi, pour les constantes, il semble que Microsoft recommande l'utilisation de camelCasing. Mais notez que ces constantes sont définies localement .

On peut soutenir que la dénomination des constantes visibles de l'extérieur présente un plus grand intérêt. En pratique, Microsoft documente ses constantes publiques dans la bibliothèque de classes .NET sous forme de champs . Voici quelques exemples:

• Int32.MaxValue
• String.Empty (en fait, static readonly)
• Math.PI
• Math.E

Les deux premiers en sont des exemples PascalCasing. Le troisième semble suivre les conventions de capitalisation de Microsoft pour un acronyme à deux lettres (bien que pi ne soit pas un acronyme). Et le quatrième semble suggérer que la règle pour un acryonyme à deux lettres s'étend à un acronyme ou identifiant à une seule lettre tel que E(qui représente la constante mathématique e ).

En outre, dans son document sur les conventions de capitalisation, Microsoft indique très directement que les identificateurs de champ doivent être nommés via PascalCasinget donne les exemples suivants pour MessageQueue.InfiniteTimeout et UInt32.Min :

public class MessageQueue
{
    public static readonly TimeSpan InfiniteTimeout;
}

public struct UInt32
{
    public const Min = 0;
}

Conclusion: à utiliser PascalCasingpour les constantes publiques (qui sont documentées en tant que constou static readonlychamps).

Enfin, pour autant que je sache, Microsoft ne préconise pas de conventions de dénomination ou de capitalisation spécifiques pour les identificateurs privés, comme indiqué dans les exemples présentés dans la question.

Laissez le hongrois aux Hongrois.

Dans l'exemple, je laisserais même de côté l'article définitif et j'irais avec

private const int Answer = 42;

Est-ce la réponse ou est-ce la réponse?

* A fait éditer comme Pascal strictement correct, cependant je pensais que la question cherchait plus d'une réponse à la vie, l'univers et tout .

En fait, j'ai tendance à préférer PascalCase ici - mais par habitude, je suis coupable de UPPER_CASE ...

ALL_CAPS est tiré de la façon de travailler C et C ++ je crois. Cet article explique ici comment les différences de style sont apparues.

Dans les nouveaux IDE tels que Visual Studio, il est facile d'identifier les types, la portée et s'ils sont constants, ce n'est donc pas strictement nécessaire.

Les logiciels FxCop et Microsoft StyleCop vous aideront à vous guider et à vérifier votre code afin que tout le monde fonctionne de la même manière.