Sto confrontando due API per generare un metodo in C # e voglio misurare quanto sia "complesso" il codice per usarle. Prendere in considerazione:
API A:
MethodDeclaration(PredefinedType(Token(IntKeyword)), "CompareTo")
.AddModifiers(Token(PublicKeyword))
.AddParameterListParameters(
Parameter(Identifier("other")).WithType(IdentifierName("Person"))
API B:
new CodeMemberMethod
{
Attributes = Public | Final,
ReturnType = new CodeTypeReference(typeof(int)),
Name = "CompareTo",
Parameters =
{
new CodeParameterDeclarationExpression("Person", "other")
}
}
(Se qualcuno è curioso, l'API A è Roslyn SyntaxFactory , API B è CodeDOM.)
Si noti come con l'API A, ci si deve preoccupare di cose come token o identificatori, che a mio parere rende più complessa. Ma:
- Se contiamo il numero di linee, l'API B è molto peggiore (4 righe contro 10 linee). Ma parte di questo è dovuto allo stile di indentazione che uso, che non riguarda in realtà la differenza tra le API.
- Se contiamo il numero di caratteri non spazi bianchi, l'API A è peggiore, ma non di molto (192 vs 175). Ma in questa metrica, l'API B è danneggiata dai suoi nomi troppo lunghi, che a mio avviso non rendono il codice più complesso.
Quindi la mia domanda è: ci sono modi per misurare questo tipo di complessità del codice, accettato nel settore o nel mondo accademico? In caso contrario, il "numero di caratteri non spazi bianchi" è il migliore che posso fare?
Altre misure di complessità che ho respinto:
- La complessità ciclomatica non è rilevante qui, poiché entrambi i casi sono espressioni non condizionali.
- La complessità di Kolmogorov è un concetto teorico che non può essere effettivamente calcolato nella pratica. Forse una qualche approssimazione potrebbe funzionare?