C'è un modo standard per contare dichiarazioni in C #

Question

stavo guardando alcune metriche lunghezza del codice diverse righe di codice. Qualcosa che dal monitor Sorgente relazioni è dichiarazioni. Questa sembrava una cosa importante da sapere, ma il modo in Monitor sorgente contato alcune cose sembravano poco intuitivo. Ad esempio, una per la dichiarazione è una dichiarazione, anche se contiene una definizione di variabile, una condizione, e una dichiarazione di incremento. E se una chiamata di metodo è annidato in una lista di argomenti a un altro metodo, il tutto è considerato uno dichiarazione.

C'è un modo standard che le dichiarazioni sono contati e sono le loro regole che disciplinano una cosa del genere?

Answer 1

Il più vicino si potrebbe arrivare a una definizione formale di "ciò che è una dichiarazione" sarebbe la C # specifica stessa. Buona fortuna lavorare fuori se la misurazione di un particolare strumento è d'accordo con la vostra lettura della specifica.

Dato che i parametri sono i più utilizzati come guida per meglio / peggio di codice, e non una formula rigorosa, non l'esatta definizione utilizzata dallo strumento fa molta differenza?

Se ho tre metodi, con "lunghezze economico" del 2500, 1500 e 150, so quale metodo sarò esaminando prima; che un altro strumento potrebbe segnalare 2480, il 1620 e il 174 non è troppo importante.

Uno dei migliori strumenti che ho visto per la misurazione delle metriche è NDepend , anche se ancora una volta sono sicuro al 100% che cosa Principali definizioni si sta usando. Secondo il sito web, NDepend dispone di 82 metriche separati , tra cui Numero di istruzioni e complessità ciclomatica .

Answer 2

La prima regola di metriche è "stare attenti a ciò che si misura". Si chiede per un conteggio di dichiarazioni, questo è quello che si vuole ottenere. Come si nota, tale cifra non è forse in realtà rilevante.

Se siete interessati ad altre misure, come come codice "complessa" è, prendere in considerazione esaminando altre metriche del codice, come la complessità cyclometric.

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

UPDATE: Re: il tuo commento

Sono d'accordo che "fare troppo" è una metrica interessante. La mia regola è che una dichiarazione dovrebbe avere un effetto collaterale (di solito un effetto collaterale "locale" come mutare una variabile locale, ma a volte un effetto collaterale visibile, come la scrittura di un file) e quindi "il numero di dichiarazioni" dovrebbe essere più o meno correlata con quanto il metodo è "fare" in termini di numero di effetti collaterali.

In pratica, naturalmente non di un codice, compresa la mia, in realtà incontra quel bar per tutto il tempo. Si potrebbe considerare una metrica per "quanto il metodo sta facendo" per contare non solo le dichiarazioni, ma anche, diciamo, chiamate di metodo.

Per rispondere alla tua domanda in realtà: io non sono a conoscenza di qualsiasi standard di settore che regola ciò che "il numero di dichiarazioni" è. Il # specifica C definisce certamente quello che una "dichiarazione" è lessicalmente, ma poi, naturalmente, si deve fare un po 'l'interpretazione di fare un conteggio. Ad esempio:

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

Quante dichiarazioni ci sono in M? Beh, il corpo di M è composto da una dichiarazione, un try-catch-finally. Così è la risposta uno? Il corpo del try contiene un'istruzione, un "if". La conseguenza del "se" contiene una dichiarazione - ricordate, un blocco è una dichiarazione. Il blocco contiene due istruzioni. Il infine contiene una dichiarazione. Il blocco catch non contiene dichiarazioni - una cattura blocco non è un istruzione , lessicalmente - ma è certamente molto importanti per il funzionamento del metodo

!

Così come molte affermazioni è che tutto? Si potrebbe fare un caso ragionevole per qualsiasi numero da uno a sei, a seconda se si contano i blocchi come dichiarazioni "reali", se si considera le dichiarazioni del bambino, come in aggiunta alla loro dichiarazione genitore o no, e così via. Non v'è alcun organismo di normalizzazione che regola la risposta a questa domanda che io sappia.

Answer 3

Il C # Metrics strumento definisce le cose che sono contati ( "dichiarazioni" , "operandi"), ecc utilizzando un C # definizione del linguaggio BNF precisa. (In realtà, analizza con precisione il codice secondo un completo C # grammatica e poi calcola metriche strutturali camminando sopra l'albero di analisi; contare SLOC ottiene da linee countline come ci si aspetterebbe).

Si potrebbe ancora obiettare che una tale definizione è poco intuitivo (grammatiche raramente sono), ma sono precisi. Sono d'accordo con altri manifesti qui, tuttavia, che la misura esatta non è importante quanto il valore relativo che un blocco di codice ha rispetto ad un altro. Un valore di "173,92" complessità semplicemente non è molto utile per sé; compard ad un altro valore la complessità di "81.02", possiamo dire che c'è una buona indicazione che il primo è più complessa di quanto la seconda, e questo è sufficiente a fornire al centro dell'attenzione.

Credo che i parametri sono utili anche nel trend; Se la scorsa settimana, questo codice era "81.02" complesso, annuncio questa settimana è "173.92", dovrei chiedo perché è tutto ciò che succede inthis parte del codice?

Si potrebbe anche prendere in considerazione un rapporto di una metrica strutturale (per esempio, Cyclomatic) per SLOC come indicazione di "fare troppo", o almeno l'indicazione del codice di scrittura che è troppo densa per capire

Answer 4

Una metrica semplice è quello di contare solo i segni di punteggiatura (;, ,, .) tra i token (in modo da evitare quelle in stringhe, commenti, o numeri). Così, for (x = 0, y = 1; x < foo.Count; x++, y++) bar[y] = foo[x]; conterebbe come 6.