Est-il un moyen standard pour compter les déclarations en C #

Question

Je regardais certains paramètres de longueur de code autre que les lignes de code. Quelque chose que les rapports Moniteur source est des déclarations. Cela semblait être une chose utile de savoir, mais la façon dont Source moniteur compté certaines choses semblaient unintuitive. Par exemple, pour une déclaration est une déclaration, même si elle contient une définition de variable, une condition et une instruction incrément. Et si un appel de méthode est imbriquée dans une liste d'arguments à une autre méthode, la chose est considérée comme l'une déclaration.

Y at-il un moyen standard que les déclarations sont comptées et sont leurs règles régissant une telle chose?

Answer 1

Le plus proche que vous pourriez obtenir une définition formelle de « ce qui est une déclaration » serait le C # spécification lui-même. Bonne chance à travailler si une mesure de l'outil de particulier est d'accord avec votre lecture de la spécification.

Étant donné que les paramètres sont mieux utilisés comme Guide pour un meilleur code / pire, et non une formule stricte, ne la définition exacte utilisée par l'outil faire beaucoup de différence?

Si j'ai trois méthodes, avec « longueurs » des états de 2500, 1500 et 150, je sais quelle méthode je vais d'abord examiner; qu'un autre outil peut signaler 2480, 1620 et 174 n'est pas trop importante.

L'un des meilleurs outils que je l'ai vu pour la mesure de paramètres est NDepend , bien qu'encore une fois je ne suis pas sûr à 100% quelles sont les définitions qu'il utilise. Selon le site, NDepend a 82 paramètres séparés , y compris Nombre d'instructions et complexité cyclomatique .

Answer 2

La première règle de mesures est « faire attention à ce que vous mesurez ». Vous demandez un nombre de déclarations, c'est ce que vous allez obtenir. Comme vous le constatez, ce chiffre est peut-être pas vraiment pertinent.

Si vous êtes intéressé par d'autres mesures, comme la façon dont le code « complexe » est, envisager la recherche d'autres mesures de code, comme la complexité cyclothermique.

http://en.wikipedia.org/wiki/Cyclomatic_complexity

MISE À JOUR: Re: votre commentaire

Je suis d'accord que « faire trop » est une mesure intéressante. Ma règle de base est que l'une déclaration devrait avoir un effet secondaire (généralement un effet secondaire « local » comme muter une variable locale, mais parfois un effet secondaire visible, comme écrire dans un fichier) et donc « nombre de déclarations » devrait être à peu près en corrélation avec la quantité de la méthode « fait » en termes de nombre d'effets secondaires.

Dans la pratique, bien sûr le code de personne, y compris le mien, répond en fait que la barre tout le temps. Vous pourriez envisager une mesure pour « combien la méthode fait » pour compter non seulement des déclarations mais aussi, disons, les appels de méthode.

Pour répondre effectivement à votre question: je ne suis pas au courant d'aucune norme de l'industrie qui réglemente ce « nombre de déclarations » est. La spécification C # définit certainement ce qu'est une « déclaration » est lexicalement, mais bien sûr, vous devez faire une interprétation pour faire un compte. Par exemple:

  void M()
  {
    try
    {
      if (blah)
      {
        Frob();
        Blob();
      }
    }
    catch(Exception ex)
    { /* eat it */ }
    finally
    {
      Grob();
    }
  }

Combien de déclarations sont là en M? Eh bien, le corps de M se compose d'une déclaration, un try-catch-finally. Alors, est une réponse? Le corps de l'essai contient une déclaration, une déclaration « si ». La conséquence de la « si » contient une déclaration - rappelez-vous, un bloc est une déclaration. Le bloc contient deux déclarations. Le contient enfin une déclaration. Le bloc catch ne comporte aucune - une prise bloc est pas instruction , lexicalement - mais il est certainement très pertinent pour le fonctionnement de la méthode

Alors, combien de déclarations est que tout à fait? On pourrait faire un cas raisonnable pour un certain nombre de un à six, selon que l'on compte des blocs comme des déclarations « vrais », si l'on considère les déclarations de l'enfant comme en plus de leur déclaration parent ou non, et ainsi de suite. Il n'y a pas organisme de normalisation qui règle la réponse à cette question que je suis au courant.

Answer 3

Le C # Metrics Tool définit les choses comptées ( "déclarations" , "opérandes"), etc. en utilisant une définition de langage précis C # BNF. (En fait, il analyse avec précision le code selon une grammaire complète C # et calcule ensuite les mesures structurelles en marchant sur l'arbre d'analyse syntaxique, SLOC compte qu'il obtient par des lignes de countline que vous attendez).

Vous pouvez toujours arguer qu'une telle définition, il unintuitive (grammaires sont rarement), mais ils sont précis. Je suis d'accord avec d'autres affiches ici, cependant, que la mesure précise n'est pas aussi importante que la valeur relative qu'un bloc de code a par rapport à l'autre. Une valeur de complexité « 173,92 » est tout simplement pas très utile par lui-même; Compard à une autre valeur de la complexité de « 81.02 », on peut dire qu'il ya une bonne indication que le premier est plus complexe que la seconde, et c'est suffisant pour fournir un centre d'attention.

Je pense que les mesures sont également utiles dans les tendances; si la semaine dernière, ce code était « 81,02 » complexe, annonce cette semaine, il est « 173,92 », je me demande pourquoi tout ce qui se passe inthis partie du code?

Vous pouvez également envisager un rapport d'une mesure structurelle (par exemple, Cyclomatic) à SLOC comme une indication de « faire trop », ou tout au moins une indication de code d'écriture qui est trop dense pour comprendre

Answer 4

Une mesure simple est de simplement compter les signes de ponctuation (;, ,, .) entre les jetons (pour éviter ceux dans des chaînes, des commentaires ou des nombres). Ainsi, for (x = 0, y = 1; x < foo.Count; x++, y++) bar[y] = foo[x]; compterait comme 6.