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 complète? J'ai entendu parler de MZ-Tools , mais existe-t-il un équivalent open source?
Visual Studio 2010 Ultimate intègre cette fonctionnalité.
Analyser -> Calculer les métriques du code
J'ai trouvé PowerShell utile pour cela. Je considère de toute façon que LoC est une métrique assez fausse, donc je ne crois pas que quelque chose de plus formel devrait être requis.
À partir du 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, placez un \n dans le champ de recherche et activez le champ des expressions régulières. Ensuite, dans les résultats de la recherche, à la fin de l'écran, figurent le nombre de fichiers recherchés et les lignes de code trouvées.
Un compteur de ligne open source pour VS2005, 2003 et 2002 est disponible ici:
Il est également question de créer un complément VS de comptage de lignes complet avec code sur Codeproject, ici
http://www.codeproject.com/KB/macros/LineCounterAddin.aspx
Les gadgets d'édition Slick ont également un compteur de lignes de Nice, ici:
http://www.slickedit.com/products/slickedit
et Microsoft Visual Studio Team System 2008 comprend un bon compteur de lignes.
Rappelez-vous simplement que:
Mesurer l’avancement de la programmation à l’aide de lignes de code revient à mesurer l’avancement de la construction d’un avion en poids. Bill Gates
Trouvé cette astuce: LOC avec VS Rechercher et remplacer
Pas un plugin si c'est ce que vous cherchez.
Voici une mise à jour de Visual Studio 2012/2013/2015 pour ceux qui souhaitent utiliser l'option "Rechercher" (que je trouve 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". Assurez-vous de sélectionner l'option "Utiliser les expressions régulières". Changez l'option de recherche en "Projet en cours" ou "Solution complète" en fonction de vos besoins. Maintenant, sélectionnez "Rechercher tout". Au bas de la fenêtre Résultats de la recherche , vous verrez "Lignes correspondantes", qui représentent le 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 soient 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 -->
Utiliser des déclarations:
using System;
using System.Web;
Ouverture des accolades:
{
Fermeture des accolades:
}
Remarque: tout ce qui est 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éé ceci pour me donner un décompte de LOC bien plus précis que certaines options précédentes, et j'ai pensé que je le partagerais. Les patrons adorent que le LOC compte, alors je suis coincé avec ça pendant un moment. J'espère que quelqu'un d'autre trouvera cela utile, laissez-moi savoir si vous avez des questions ou si vous avez besoin d'aide pour le faire fonctionner.
cloc est une excellente ligne de commande, basée sur Perl, exécutable sous Windows, qui décompose les lignes vides, les lignes commentées et les lignes de code source, regroupées par formats de fichier.
À présent, il ne s'exécutera pas spécifiquement sur un fichier de solution de VS, mais il peut effectuer une récurrence à travers des répertoires et vous pouvez configurer les filtres de nom de fichier comme bon vous semble.
Voici l'exemple de sortie de leur page Web:
Invite> 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 Commentaire vide Echelle 3ème gén. equiv ------------------------------------------------ ----------------------------------- Perl 2052 110356 112521 309778 x 4.00 = 1239112.00 C 135 18718 22862 140483 x 0,77 = 108171.91 C/C++ En-tête 147 7650 12093 44042 x 1,00 = 44042,00 Bourne Shell 116 3402 5789 36882 x 3,81 = 140520,42 LISP 1 684 2242 7515 x 1,25 = 9393,75 7 498 473 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 0 499 x 0,90 = 440,10 DOS Lot 11 85 50 322 x 0,63 = 202,86 HTML 1 19 2 98 x 1,90 = 186,20 ------------------------ -------------------------------------------------- ----- SUM: 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 très utile, mais intéressant quand même.
Les réponses ici sont un peu obsolètes, peuvent être de 2008 vs. Dans les nouvelles versions 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.
Fonction permettant de compter les lignes de code - Calculer les métriques. Avec lui, vous pouvez calculer vos métriques (LOC, index de maintien, index cyclomatic, profondeur de l'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. Également dans Excel, vous pouvez filtrer les classes générées ou tout autre bruit de vos métriques. Ces métriques, y compris les lignes de code LOC, peuvent également être rassemblées pendant le processus de construction et incluses dans le rapport de construction.
Les expressions régulières ont changé entre VS2010 et 2012, de sorte que la plupart des solutions d'expression régulière ne fonctionnent plus ici.
(^(?!(\s*//.+)))+(^(?!(#.+)))+(^(?!(\s*\{.+)))+(^(?!(\s*\}.+)))+(^(?!(\s*\r?$)))+
Trouvera toutes les lignes qui ne sont pas vides, ne sont pas un simple crochet ('{' ou '}') et pas seulement un #include ou un autre préprocesseur.
Utilisation Ctrl-shift-f et 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 utiliser le menu Analyser -> "Calculer les métriques de code pour la solution" et vous obtiendrez un nombre de lignes de votre solution complète (entre autres: g).
Pour les futurs lecteurs, je voudrais conseiller le extension DPack pour Visual Studio 201 .
Il contient de nombreux utilitaires, dont un compteur de lignes indiquant le nombre de lignes vides, de 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 des résultats de la recherche, vous devriez voir une ligne du type:
Matching lines: 563 Matching files: 17 Total files searched: 17
Bien sûr, cela n’est pas très utile pour les grands projets, car toutes les lignes sont machées et chargées en mémoire pour être affichées dans la fenêtre des résultats de la recherche.
Référence:
Vous pouvez utiliser:
- SCLOCCount http://www.dwheeler.com/sloccount/ - Open source
- métrique loc, http://www.locmetrics.com/ - pas en open source, mais facile à utiliser
Je préfère métriques OxyProject VS Addin.
Évidemment, les outils sont plus faciles, mais je me sens bien en faisant ça dans 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 les propriétés suivantes: Solution, Projet, Fichier, Lignes. Il stocke tous ces objets dans une liste, puis regroupe et projette les données en fonction des 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 (source ouverte): http://www.accendo.sk/Download/SourceStat.Zip
Utilisez l'option Menu-> Analyse -> Calculer les métriques du code dans Visual Studio 2010 Ultimate.
Vous pouvez utiliser Code de métrique Visual Studio PowerTool 10. . C'est un utilitaire de ligne de commande qui calcule quelques métriques sur le code géré pour vous (y compris les lignes de code). Vous pouvez obtenir un plug-in VS 2010 qui amène l'outil dans Visual Studio , et le rend aussi rapide que de sélectionner l'élément de menu, puis de cliquer sur "Analyser la solution".
Voici le tour .. 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
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 sur un site de téléchargement un outil connexe. http://www.cnet.com/1770-5_1-0.html?query=code+counter&tag=srch
Je suis venu avec un script PowerShell rapide et sale pour compter les lignes dans une structure de dossier. Il est loin d'être 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:
Vous pouvez utiliser le complément Compteur de lignes de projet dans Visual Studio 2010. En règle générale, cela ne fonctionne pas avec Visual Studio 2010, mais avec un fichier .reg utile à partir d'ici: http: //www.onemanmmo. com/index.php? cmd = newsitem & comment = news.1.41.
Dans Visual Studio 2015, accédez au menu Analyse et sélectionnez "Calculer les métriques du code".
Essayez Neptuner. Il vous donne également des choses comme des espaces, des onglets, des lignes de commentaires en plus de la LoC. http://neptuner.googlecode.com/files/neptuner_0_30_windows.Zip