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

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?

Visual Studio 2010 Ultimate a ce intégré:

Analyser → Calculer les métriques de code

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? :)

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).

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

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.

Trouvé cette astuce: LOC avec VS Trouver et remplacer

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

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.

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,

et sélectionnez "Calculer les métriques"

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

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@/#).+

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 )

Pour les futurs lecteurs, je voudrais conseiller l' extension DPack pour Visual Studio 2010 .

Il contient de nombreux utilitaires, dont un compteur de lignes indiquant le nombre de lignes vides, le code, etc.

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:

• Exemple avancé

Vous pouvez utiliser:

• SCLOCCount http://www.dwheeler.com/sloccount/ - Open source
• loc metrics, http://www.locmetrics.com/ - pas open source, mais facile à utiliser

Je préfère OxyProject Metrics VS Addin.

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}

Autre outil simple pour VS2008 (open source): http://www.accendo.sk/Download/SourceStat.zip

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

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».

D'accord avec Ali Parr. Le complément WndTab Line Counter est un tel outil. http://www.codeproject.com/KB/macros/linecount.aspx

C'est également une bonne idée de rechercher à partir du site de téléchargement pour trouver un outil connexe. http://www.cnet.com/1770-5_1-0.html?query=code+counter&tag=srch

Voici le Trick .. Il compte également le fichier Js.

http://www.spoiledtechie.com/post/2011/11/22/How-To-Count-Lines-of-Code-in-Visual-Studio.aspx

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

Vous pouvez utiliser le complément Project Line Counter dans Visual Studio 2010. Normalement, il ne fonctionne pas avec Visual Studio 2010, mais il le fait avec un fichier .reg utile à partir d'ici: http://www.onemanmmo.com/index. php? cmd = newsitem & comment = news.1.41.0

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

Essayez neptuner. Il vous donne également des choses comme des espaces, des tabulations, des lignes de commentaires en plus de LoC. http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip

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