Comment comptez-vous les lignes de code dans une solution Visual Studio?

800

Est-il possible de trouver le nombre de lignes de code dans une solution entière? J'ai entendu parler de MZ-Tools , mais existe-t-il un équivalent open source?

Fermin
la source
24
Je suis d'accord que ça n'aide pas beaucoup mais si la direction le demande ...
Fermin
33
La LoC est simplement une métrique et est particulièrement intéressante dans 2 cas: 1) pour avoir une idée de la taille de la base de code, c'est-à-dire lorsque vous rejoignez une nouvelle équipe 2) pour mesurer vos progrès lorsque vous essayez de rendre votre base de code plus compacte
Piotr Owsiak
191
Certaines personnes ici disent que compter les lignes de code est inutile sans y penser. C'est très utile car c'est une métrique qui devrait généralement être minimisée. Il s'agit d'un moyen simple de mesurer la complexité de la solution (et non son efficacité) et si le problème est connu pour être simple, plus il y a de lignes de code, plus la qualité est généralement faible. Une autre chose est pourquoi les gens prennent-ils la peine de répondre si c'est juste pour dire que la question est mauvaise? Que penseriez-vous si un enseignant vous disait que votre question ne devrait tout simplement pas être posée.
77
Dans VS2010, il existe un outil intégré qui compte également toutes les lignes de code et d'autres valeurs: Allez dans Affichage -> Autres fenêtres -> Résultats des mesures de code. Un petit bouton dans le coin qui ressemble à un calendrier, cliquez dessus, l'info-bulle devrait dire Calculer les métriques de code pour soulution, et laisser VS faire la chose.
user959631
64
La personne n'a pas toujours besoin de vous dire pourquoi elle veut compter le code. Lorsque la question est simplement énoncée, la question de savoir pourquoi n'est pas pertinente. Répondez à sa question. Je déteste ça. Il y a des moments pour demander pourquoi quand clairement vous en avez besoin et puis il y en a des fois où (vous ne voyez pas personnellement un besoin ... et vous harcelez l'affiche avec arrogance).
PositiveGuy

Réponses:

525

Visual Studio 2010 Ultimate a ce intégré:

Analyser → Calculer les métriques de code

Herter
la source
12
Ultimate et Premium, je pense
Stefan Dragnev
39
Avertissement: Cela fait bien d'autres choses que le simple comptage de lignes. Il répertorie également "Indice de maintenabilité", "Complexité cyclomatique", "Profondeur d'héritage" et "Couplage de classes", qui sont tous assez compliqués à calculer, et vous ne pouvez pas exécuter les métriques pour une partie seulement. Cela signifie que si votre base de code est particulièrement volumineuse, vous pouvez être assis pendant des heures à l'attendre. Si tout ce que vous voulez, c'est le nombre de lignes, il existe des solutions beaucoup plus rapides.
Darrel Hoffman le
4
également sur vs2012 ultimate =)
oCcSking
9
VS 2013 a Analyser -> Calculer les métriques de code
Dinesh Rajan
42
Dommage que cela ne fonctionne pas avec les projets C ++ natifs (du moins, ce n'est pas le cas dans VS2013).
Cameron
844

J'ai trouvé PowerShell utile pour cela. Je considère que LoC est de toute façon une métrique assez fausse, donc je ne pense pas que quelque chose de plus formel devrait être requis.

Depuis le répertoire d'une petite solution:

PS C:\Path> (gci -include *.cs,*.xaml -recurse | select-string .).Count
8396
PS C:\Path>

Cela comptera les lignes non vides dans tous les fichiers .cs et .xaml de la solution. Pour un projet plus important, je viens d'utiliser une liste d'extensions différente:

PS C:\Other> (gci -include *.cs,*.cpp,*.h,*.idl,*.asmx -recurse | select-string .).Count
909402
PS C:\Other>

Pourquoi utiliser une application entière alors qu'une seule ligne de commande le fera? :)

Greg D
la source
19
(La seule fois où on m'a demandé de fournir le nombre de lignes, c'était lorsque la haute direction déterminait combien de temps il faudrait pour migrer tous nos produits à l'étranger afin de pouvoir fermer notre site national.)
Greg D
8
(Oui, cela inclut les fichiers et commentaires codés. Non, cela ne me dérange pas. Les concepteurs, le code généré et les commentaires doivent également être conservés.)
Greg D
27
très agréable, complètement oublié PowerShell. il devrait devenir le remplacement par défaut de cmd
lubos hasko
4
Excellent! Votre commentaire final le résume vraiment, c'est une tâche triviale, alors pourquoi utiliser un outil non trivial? Bien que je pense vraiment qu'il devrait être inclus dans toutes les versions de VS.
Sune Rievers
13
Si vous souhaitez exclure les fichiers de sauvegarde générés pour le XAML, vous pouvez simplement ajouter un commutateur -exclude: (dir -exclude *.g.cs -include *.cs,*.xaml -recurse | select-string .).Count
EZ Hart
349

J'ai utilisé Ctrl+ Shift+ F. Ensuite, mettez un \ndans la zone de recherche et activez la zone d'expressions régulières. Ensuite, dans les résultats de la recherche, à la fin de l'écran se trouvent le nombre de fichiers recherchés et les lignes de code trouvées.

Vous pouvez utiliser [^\n\s]\r\npour ignorer les lignes vides et l'espace uniquement (crédits à Zach dans les commentaires).

NicolásKittsteiner
la source
16
Cette solution inclut de manière incorrecte des lignes vides, des commentaires, de la documentation et des instructions fractionnées. Pour de nombreuses applications, celles-ci ne doivent pas compter comme des lignes de code.
Jay Baxter
1
Bien qu'elle soit légèrement inexacte (si vous utilisez réellement \ n dans votre code, cette ligne sera comptée deux fois), c'est toujours la meilleure réponse si vous avez besoin d'une ROM de lignes de code sans outil tiers
Joseph Duty
1
Vous pouvez également sélectionner un type de fichier spécifique en sélectionnant une Look at these file types:liste déroulante d' options juste en dessous du enable regular expressions box.
Moshii
1
Fonctionne pour de très petits projets ... lorsque vous avez 100 millions de lignes de code, cela prendra un certain temps.
marais
11
[^\n\s]\r\nsaute les lignes vides, même avec des espaces.
Zach Mierzejewski
219

Un compteur de ligne open source pour VS2005, 2003 et 2002 est disponible ici:

http://www.wndtabs.com/

Il est également question de créer un add-in de comptage de lignes VS, avec du code sur Codeproject, ici

http://www.codeproject.com/KB/macros/LineCounterAddin.aspx

Les gadgets Slick Edit ont également un joli compteur de lignes, ici:

http://www.slickedit.com/products/slickedit

et Microsoft Visual Studio Team System 2008 comprend un bon compteur de lignes.

N'oubliez pas cependant:

Mesurer la progression de la programmation par des lignes de code, c'est comme mesurer la progression du bâtiment d'un avion en poids. Bill Gates

Ali Parr
la source
1
Souvent, compter des lignes de code est simplement stupide, et la quantité n'implique pas la qualité. Cependant, une énorme équipe mettant un Dreamliner de 545 000 lb (545 000 lb !!) en l'air est une réalisation entièrement différente de celle de lancer l'ultra-léger que j'ai construit à lui seul dans mon garage. Et si vous pensez au nombre de lignes de code dans Windows, peut-être que M. Bill a voulu dire cela d'une manière différente de celle habituellement utilisée ...?
UnconditionallyReinstateMonica
18
Aucun de ceux-ci ne semble s'appliquer à Visual Studio 2010 et le lien slickedit est rompu.
MGOwen
57
Vous trouverez la fonctionnalité LOC dans Visual Studio 2010 Ultimate sous "Analyse> Mesures de code" J'espère que je l'ai bien traduite. J'ai la version allemande. Là, c'est "Analyser"> "Codemetriken berechnen"
OneWorld
2
pour Visual Studio 2012, la métrique LoC peut être trouvée sur ANALYZE> Calculer les métriques de code pour la solution
tetri
2
De plus, VS2012 inclut cette fonctionnalité dans les éditions Ultimate et Premium (et maintenant Professional également).
SWalters
81

Voici une mise à jour pour Visual Studio 2012/2013/2015 pour ceux qui veulent faire l'option "Rechercher" (que je trouve être la plus simple): ce RegEx trouvera toutes les lignes non vides avec plusieurs exclusions pour donner les résultats les plus précis .

Entrez le RegEx suivant dans la case "Rechercher". Veuillez vous assurer de sélectionner l'option "Utiliser les expressions régulières". Modifiez l'option de recherche en "Projet en cours" ou "Solution entière" en fonction de vos besoins. Sélectionnez maintenant "Rechercher tout". Au bas de la fenêtre Résultats de la recherche , vous verrez "Lignes correspondantes" qui correspond au nombre de lignes de code.


^(?!(\s*\*))(?!(\s*\-\-\>))(?!(\s*\<\!\-\-))(?!(\s*\n))(?!(\s*\*\/))(?!(\s*\/\*))(?!(\s*\/\/\/))(?!(\s*\/\/))(?!(\s*\}))(?!(\s*\{))(?!(\s(using))).*$

Ce RegEx exclut les éléments suivants:


commentaires

// This is a comment

Commentaires multilignes (en supposant que les lignes sont correctement commentées avec un * devant chaque ligne)

/* I am a
* multi-line
* comment */

XML pour Intellisense

/// <summary>
/// I'm a class description for Intellisense
/// </summary>

Commentaires HTML:

<!-- I am a HTML Comment -->

Utilisation de déclarations:

using System;
using System.Web;

Ouverture des accolades:

{

Fermeture des accolades:

}

Remarque: tout ce qui se trouve entre les accolades serait inclus dans la recherche, mais dans cet exemple, seules 4 lignes de code compteraient, au lieu de 18 lignes réelles non vides:

        public class Test
        {
            /// <summary>
            /// Do Stuff
            /// </summary>
            public Test()
            {
                TestMe();
            }
            public void TestMe()
            {
                //Do Stuff Here
                /* And
                 * Do
                 * Stuff
                 * Here */
            }
        }

J'ai créé cela pour me donner un compte LOC beaucoup plus précis que certaines options précédentes, et j'ai pensé que je partagerais. Les patrons aiment les comptes du LOC, donc je suis coincé avec ça pendant un moment. J'espère que quelqu'un d'autre pourra trouver cela utile, faites-moi savoir si vous avez des questions ou avez besoin d'aide pour le faire fonctionner.

Howard Renollet
la source
18
J'adore le downvote sans commentaire. Cela ne devrait pas être autorisé. Et ma solution ne fonctionne pas ??? Je ne me soucie même pas des votes, je voulais juste publier une mise à jour pour les utilisateurs de VS2012-2013.
Howard Renollet
Difficile de filtrer tout le code généré (AssemblyInfo, etc.), il est donc préférable d'analyser / calculer les mesures de code.
MKesper
4
Excellent travail, mais veuillez mentionner la case Utiliser l'expression régulière dans la section Options de recherche . Ça rend beaucoup plus facile
Gogutz
@MKesper MAIS CELA NE FONCTIONNE PAS POUR C ++
d7samurai
Une version plus simple sans XML, ni HTML ... ^ (? ([^ \ R \ n]) \ s) * [^ \ s +? /] + [^ \ N] * $.
LastBlow
80

Trouvé cette astuce: LOC avec VS Trouver et remplacer

Ce n'est pas un plugin si c'est ce que vous recherchez.

Mads Andersen
la source
J'adore celui-ci, mais je pense avoir trouvé une petite erreur dans l'expression là-bas. Pour VB.Net, je pense que ce devrait être ^ ~ (: Wh @ ') ~ (: Wh @ \ #). + Et pour C # je pense ^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #). + De cette façon, les lignes de commentaires vides et les directives du compilateur sont correctement traitées. Cela a mieux fonctionné pour moi avec VB.NET de toute façon, et C # je n'ai pas testé.
user12861
^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #) ~ (: Wh @ $). + A fini fonctionnant mieux pour C #, je recevais des lignes constituées uniquement d'espaces.
user12861
Ne compte-t-il pas également toutes les lignes commentées? Juste des lignes de CODE s'il vous plaît!
HydPhani
4
En voici une que j'ai créée avec qui fonctionne dans VS2012 (celle publiée est obsolète depuis 2010) et ne compte que les lignes de code. Il exclut tous les commentaires, en utilisant des directives, des accolades, des directives xml, des lignes vides, etc ... pour vous donner un vrai code seulement: ^ (?! (\ S **)) (?! (\ S * \ - \ - \>)) (?! (\ s * \ <\! \ - \ -)) (?! (\ s * \ n)) (?! (\ s ** \ /)) (?! (\ s * \ / *)) (?! (\ s * \ / \ / \ /)) (?! (\ s * \ / \ /)) (?! (\ s * \})) (? ! (\ s * \ {)) (?! (\ s (utilisant))). * $
Howard Renollet
65

cloc est une excellente ligne de commande, basée sur Perl, exécutable par Windows qui décomposera les lignes vides, les lignes commentées et les lignes source de code, regroupées par formats de fichiers.

Maintenant, il ne s'exécutera pas spécifiquement sur un fichier de solution VS, mais il peut récursivement via des répertoires, et vous pouvez configurer des filtres de nom de fichier comme bon vous semble.

Voici l'exemple de sortie de leur page Web:

prompt> cloc perl-5.10.0.tar.gz
    4076 fichiers texte.
    3883 fichiers uniques.                                          
    1521 fichiers ignorés.

http://cloc.sourceforge.net v 1.07 T = 10,0 s (251,0 fichiers / s, 84566,5 lignes / s)
-------------------------------------------------- -----------------------------
Fichiers de langue, échelle de code de commentaire vierge, 3e génération. équiv
-------------------------------------------------- -----------------------------
Perl 2052 110356 112521 309778 x 4,00 = 1239112,00
C 135 18718 22862 140483 x 0,77 = 108171,91
En-tête C / C ++ 147 7650 12093 44042 x 1,00 = 44042,00
Bourne Shell 116 3402 5789 36882 x 3,81 = 140520,42
Lisp 1684 2242 7515 x 1,25 = 9393,75
faire 7498473 2044 x 2,50 = 5110,00
C ++ 10 312 277 2000 x 1,51 = 3020,00
XML 26 231 0 1972 x 1,90 = 3746,80
yacc 2 128 97 1549 x 1,51 = 2338,99
YAML 2 2 0 489 x 0,90 = 440,10
Lot DOS 11 85 50322 x 0,63 = 202,86
HTML 1 19 2 98 x 1,90 = 186,20
-------------------------------------------------- -----------------------------
SOMME: 2510 142085 156406 547174 x 2,84 = 1556285,03
-------------------------------------------------- -----------------------------

L'échelle équivalente de troisième génération est une estimation approximative de la quantité de code qu'il faudrait dans un langage de troisième génération . Pas terriblement utile, mais intéressant quand même.

Mark Rushakoff
la source
1
C'est génial et super facile à utiliser. Beaucoup plus facile que les solutions Find / Replace et plus clair ce qu'il fait réellement que l'option VS Code Metrics. Juste choco install clocet puis cloc .dans votre dir solution. Travail accompli!
Rory
1
J'ai téléchargé l'EXE Windows à partir du site Web CLOC et l'ai exécuté dans mon dossier de projet de site Web Visual Studio 2017. A fonctionné comme un charme. J'aime l'option --by-file-by-lang qui répertorie le nombre de lignes par fichier individuel et par langue, triées du plus grand au plus petit.
humbads
42

Les réponses ici sont un peu obsolètes, peut-être par rapport à 2008. Parce que dans les versions plus récentes de Visual Studio 2010/2012, cette fonctionnalité est déjà intégrée. Il n'y a donc aucune raison d'utiliser une extension ou des outils pour cela.

Fonctionnalité pour compter les lignes de code - Calculer les métriques. Avec lui, vous pouvez calculer vos métriques (LOC, index de maintenance, index cyclomatique, profondeur d'héritage) pour chaque projet ou solution.

Faites un clic droit sur la solution ou le projet dans l'Explorateur de solutions,

entrez la description de l'image ici

et sélectionnez "Calculer les métriques"

entrez la description de l'image ici

Les données ultérieures pour l'analyse et l'agrégation pourraient être importées dans Excel. Dans Excel, vous pouvez également filtrer les classes générées ou tout autre bruit provenant de vos mesures. Ces mesures, y compris les lignes de code LOC, peuvent également être collectées pendant le processus de génération et incluses dans le rapport de génération

Regfor
la source
2
Visual Studio 2010 a également ces mesures. En fait, rien de nouveau dans VS2012.
Mike Chaliy
1
Oui, mais les réponses ici datent de 2008 par rapport à 2008 et sont un peu obsolètes, pourquoi utiliser quoi que ce soit ou installer une extension quand c'est une fonctionnalité intégrée. Et même ce n'est pas une nouvelle fonctionnalité que beaucoup de gens ne connaissent pas.
Regfor
@MikeChaliy Peut-être que la deuxième phrase d'introduction vous a confondu, je l'ai donc réécrite un peu pour éviter une telle confusion.
Regfor
j'ai une solution à n couches mais qui affiche cette erreur: "Une exception a été levée par la cible d'une invocation." Pourquoi?
user197508
5
Ce ne sont pas des lignes de code, mais des lignes compilées (c'est-à-dire après leur transformation en IL). Je pense que Fermin cherchait des lignes pré-compilées.
mikeschuld
29

Les expressions régulières ont changé entre VS2010 et 2012, donc la plupart des solutions d'expression régulière ici ne fonctionnent plus

(^(?!(\s*//.+)))+(^(?!(#.+)))+(^(?!(\s*\{.+)))+(^(?!(\s*\}.+)))+(^(?!(\s*\r?$)))+

Trouvera toutes les lignes qui ne sont pas vides, ne sont pas seulement un seul crochet ('{' ou '}') et pas seulement un #include ou un autre préprocesseur.

Utilisez Ctrl- shift- fet assurez-vous que les expressions régulières sont activées.

L'expression régulière correspondante pour VS 2010 et les versions antérieures est

^~(:Wh@//.+)~(:Wh@\{:Wh@)~(:Wh@\}:Wh@)~(:Wh@/#).+
user2711915
la source
19

Dans Visual Studio Team System 2008, vous pouvez le faire à partir du menu Analyser -> 'Calculer les métriques de code pour la solution' et cela vous donnera un nombre de lignes de votre solution entière (entre autres g )

Christopher Klein
la source
12
Visual Studio Team System 2008 ne parvient pas à compter le code non managé. ;)
Christian
11

Une solution simple consiste à rechercher dans tous les fichiers. Tapez "*" lorsque vous utilisez des caractères génériques. Ce qui correspondrait à toutes les lignes. À la fin de la fenêtre de résultats de recherche, vous devriez voir une ligne du type:

Matching lines: 563 Matching files: 17 Total files searched: 17

Bien sûr, ce n'est pas très bon pour les grands projets, car toutes les lignes sont usinées et chargées en mémoire pour être affichées dans la fenêtre de résultats de recherche.

Référence:

Sogartar
la source
4

De toute évidence, les outils sont plus faciles, mais je me sens cool de le faire en PowerShell :)

Ce script trouve toutes les références .csproj dans le fichier .sln, puis dans chaque fichier csproj, il localise les fichiers inclus pour la compilation. Pour chaque fichier inclus pour la compilation, il crée un objet avec des propriétés: Solution, Projet, Fichier, Lignes. Il stocke tous ces objets dans une liste, puis regroupe et projette les données selon les besoins.

#path to the solution file e.g. "D:\Code\Test.sln"
$slnFile = "D:\Code\Test.sln"


#results
$results = @()

#iterate through .csproj references in solution file
foreach($projLines in get-item $slnFile | Get-Content | Select-String '".*csproj')
{
    $projFile = [System.IO.Path]::Combine([System.IO.Path]::GetDirectoryName($slnFile), [regex]::Match($projLines,'[^"]*csproj').Value)
    $projFolder = [System.IO.Path]::GetDirectoryName($projFile)

    #from csproj file: get lines for files to compile <Compile Include="..."/>
    $includeLines = get-item $projFile | Get-Content | Select-String '<Compile Include'


    #count of all files lines in project
    $linesInProject = 0;
    foreach($fileLine in $includeLines)
    {
        $includedFilePath = [System.IO.Path]::Combine($projFolder, [Regex]::Match($fileLine, '"(?<file>.*)"').Groups["file"].Value)
        $lineCountInFile = (Get-Content $includedFilePath).Count      
        $results+=New-Object PSObject -Property @{ Solution=$slnFile ;Project=$projFile; File=$includedFilePath; Lines=$lineCountInFile }
    }
}

#filter out any files we dont need
$results = $results | ?{!($_.File -match "Designer")}


#print out:

"---------------lines per solution--------------"
$results | group Solution | %{$_.Name + ": " + ($_.Group | Measure-Object Lines -Sum).Sum}
"---------------lines per peoject--------------"
$results | group Project | %{$_.Name + ": " + ($_.Group | Measure-Object Lines -Sum).Sum}
anakic
la source
3

Utilisez l'option Menu-> Analyser -> Calculer les mesures de code dans Visual Studio 2010 Ultimate.

sunil
la source
3

Vous pouvez utiliser Visual Studio Code Metrics PowerTool 10.0 . Il s'agit d'un utilitaire de ligne de commande qui calcule pour vous quelques métriques sur le code managé (y compris les lignes de code). Vous pouvez obtenir un plug-in VS 2010 qui introduit l'outil dans Visual Studio et le rend aussi rapide que de sélectionner l'élément de menu et de cliquer sur «Analyser la solution».

Travis
la source
2

Vous pouvez utiliser l'outil gratuit SourceMonitor

Donne beaucoup de mesures: lignes de code, nombre d'instructions, complexité, profondeur de bloc

A des sorties graphiques via des graphiques

Hovhannes Hakobyan
la source
1

J'ai trouvé un script PowerShell rapide et sale pour compter les lignes dans une structure de dossiers. Il n'est pas aussi complet que certains des autres outils référencés dans d'autres réponses, mais je pense qu'il est assez bon pour fournir une comparaison approximative de la taille des fichiers de code les uns par rapport aux autres dans un projet ou une solution.

Le script peut être trouvé ici:

https://gist.github.com/1674457

Jesse Taber
la source
0

Dans Visual Studio 2015, accédez au menu Analyser et sélectionnez «Calculer les mesures de code».

Atters
la source