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 y a-t-il un équivalent open source?
25 réponses
Visual Studio 2010 Ultimate a ceci intégré.
Analyser - > Calculer Les Paramètres Du Code
j'ai trouvé powershell utile pour cela. Je considère que LoC est une métrique assez bidon de toute façon, donc je ne pense pas que quelque chose de plus formel devrait être nécessaire.
du répertoire d'une petite solution:
PS C:\Path> (gci -include *.cs,*.xaml -recurse | select-string .).Count
8396
PS C:\Path>
qui va compter les lignes non vides dans toutes les solutions .cs et .les fichiers xaml. Pour un projet plus important, je viens d'utiliser une liste d'extension différente:
PS C:\Other> (gci -include *.cs,*.cpp,*.h,*.idl,*.asmx -recurse | select-string .).Count
909402
PS C:\Other>
Pourquoi utiliser un toute application lorsqu'une seule ligne de commande va faire? :)
j'ai utilisé Ctrl + Shift + F . Ensuite, mettez un \n dans la boîte de recherche et activez la boîte des expressions régulières. Ensuite, dans les résultats de recherche, à la fin de l'écran se trouve le nombre de fichiers recherchés et les lignes de code trouvées.
open source en ligne de compteur pour VS2005, 2003 et 2002 est disponible ici:
il est également question de créer une ligne counting VS addin, complète avec le code sur Codeproject, ici
http://www.codeproject.com/KB/macros/LineCounterAddin.aspx
aussi astucieux Gadgets D'édition ont une belle ligne-compteur, ici:
http://www.slickedit.com/products/slickedit
et Microsoft Visual Studio Team System 2008 comprend un bon compteur de ligne.
rappelez-vous:
mesurer la progression de la programmation par des lignes de code, c'est comme mesurer la progression de la construction d'un aéronef par le poids. Bill Gates
trouvé ce bout: LOC avec VS Find et remplacer
pas un plugin cependant si c'est ce que vous recherchez.
Voici une mise à jour pour Visual Studio 2012/2013/2015 pour ceux qui veulent faire l'option" Find " (que je trouve la plus facile): ce RegEx va trouver toutes les lignes non Vierges avec plusieurs exclusions pour donner les résultats les plus précis.
entrez la RegEx suivante dans la case" trouver". Veuillez vous assurer de sélectionner l'option "Utiliser des Expressions régulières". Changez l'option de recherche en "projet actuel" ou "Solution entière" selon vos besoins. Maintenant, sélectionnez "Trouver Tout". Au bas de la fenêtre trouver les résultats , vous verrez" lignes correspondantes " qui est le nombre de lignes du code.
^(?!(\s*\*))(?!(\s*\-\-\>))(?!(\s*\<\!\-\-))(?!(\s*\n))(?!(\s*\*\/))(?!(\s*\/\*))(?!(\s*\/\/\/))(?!(\s*\/\/))(?!(\s*\}))(?!(\s*\{))(?!(\s(using))).*$
ce RegEx exclut les articles suivants:
commentaires
// This is a comment
les commentaires Multi-lignes (en supposant que les lignes soient correctement commentées avec un * devant chaque ligne)
/* I am a
* multi-line
* comment */
XML for Intellisense
/// <summary>
/// I'm a class description for Intellisense
/// </summary>
Commentaires HTML:
<!-- I am a HTML Comment -->
à l'Aide des déclarations:
using System;
using System.Web;
broches à ouvrir:
{
la Fermeture des accolades:
}
Note: n'importe quoi entre les accolades serait inclus dans la recherche, mais dans cet exemple seulement 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 nombre de LOC beaucoup plus précis que certaines options précédentes, et j'ai pensé que je partagerais. Les patrons adorent LOC counts, donc je suis coincé avec elle pendant un certain temps. J'espère que quelqu'un d'autre peut trouver cela utile, laissez-moi savoir si vous avez des questions ou besoin d'aide à la faire fonctionner.
cloc est une excellente ligne de commande, basée sur Perl, Windows-executable qui va décomposer les lignes vierges, les lignes commentées, et les lignes source du code, groupées par les formats de fichier.
maintenant, il ne sera pas lancé spécifiquement sur un fichier VS solution, mais il peut revenir à travers les répertoires, et vous pouvez configurer des filtres de nom de fichier comme vous le souhaitez.
Voici la sortie d'échantillon de leur page web:
prompt> cloc perl-5.10.0.tar.gz
4076 text files.
3883 unique files.
1521 files ignored.
http://cloc.sourceforge.net v 1.07 T=10.0 s (251.0 files/s, 84566.5 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code scale 3rd gen. equiv
-------------------------------------------------------------------------------
Perl 2052 110356 112521 309778 x 4.00 = 1239112.00
C 135 18718 22862 140483 x 0.77 = 108171.91
C/C++ Header 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
make 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 489 x 0.90 = 440.10
DOS Batch 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'elle prendrait 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 périmées, peut-être à l'heure vs 2008. Parce que dans les nouvelles versions 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 pour compter les lignes de code-Calculer les mesures. Avec elle, vous pouvez calculer vos paramètres (LOC, Maintaince index, Cyclomatic index, Depth of inheritence) pour chaque projet ou solution.
cliquez sur le bouton droit de la souris solution ou un projet dans l'Explorateur de solutions,
et sélectionnez "Calculer les paramètres"
plus tard les données pour l'analyse et l'agrégation pourraient être importées à Excel. Aussi dans Excel vous pouvez filtrer les classes générées, ou d'autres bruits de vos mesures. Ces mesures, y compris les lignes de code LOC, pourraient être recueillies aussi pendant le processus de construction, et incluses dans la construction. rapport
expressions Régulières ont changé entre VS2010 et 2012, de sorte que la plupart de l'expression régulière solutions ne fonctionnent plus
(^(?!(\s*//.+)))+(^(?!(#.+)))+(^(?!(\s*\{.+)))+(^(?!(\s*\}.+)))+(^(?!(\s*\r?$)))+
trouvera toutes les lignes qui ne sont pas vides, qui ne sont pas seulement un simple bracket ( '{' ou '}' ) et pas seulement un #include ou un autre préprocesseur.
utiliser Ctrl - shift - f et s'assurer que les expressions régulières sont activées.
l'expression régulière correspondante pour VS 2010 et plus est
^~(:Wh@//.+)~(:Wh@\{:Wh@)~(:Wh@\}:Wh@)~(:Wh@/#).+
dans Visual Studio Team System 2008, vous pouvez faire à partir du menu Analyser -- > 'calculer des paramètres de Code pour la Solution' et il vous donnera un compte de ligne de votre solution entière (entre autres choses g )
pour les futurs lecteurs, je vous conseille L'extension DPack pour Visual Studio 2010 .
il a une charge des utilités construites en incluant un compteur de ligne qui dit combien de lignes sont vides, code, et etc.
une solution simple est de rechercher dans tous les fichiers. Tapez " * " en utilisant les caractères génériques. Qui correspondent à toutes les lignes. À la fin de la fenêtre résultats de la recherche vous devriez voir une ligne du genre:
Matching lines: 563 Matching files: 17 Total files searched: 17
bien sûr, ce n'est pas très bon pour les grands projets, puisque toutes les lignes sont mises en mémoire et chargées en mémoire pour être dissipées dans la fenêtre de résultats de recherche.
référence:
vous pouvez utiliser:
- SCLOCCount http://www.dwheeler.com/sloccount / - Open source
- loc métriques, http://www.locmetrics.com/ - pas open source, mais facile à utiliser
évidemment les outils sont plus faciles, mais je me sens cool de le faire en powershell:)
ce script trouve tous les .références csproj dans le .sln file, puis dans chaque fichier csproj il localise les fichiers inclus pour la compilation. Pour chaque fichier qui est 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 groupe 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
Utiliser le Menu-> Analyse - > Calculer les Métriques de Code option dans Visual Studio 2010 Ultimate.
vous pouvez utiliser le Visual Studio Code Metrics PowerTool 10.0 . C'est un utilitaire de ligne de commande qui calcule quelques paramètres sur le code géré pour vous (y compris les lignes de code). Vous pouvez obtenir un VS 2010 plugin que apporte l'outil dans Visual Studio , et le rend aussi rapide que la sélection de l'élément de menu et en cliquant sur " Analyser Solution."
d'Accord avec Ali Parr. Le Wndtab Line Counter addin est un tel outil. http://www.codeproject.com/KB/macros/linecount.aspx
il est également une bonne idée de rechercher à partir du site de téléchargement pour trouver un outil lié. http://www.cnet.com/1770-5_1-0.html?query=code + counter & tag=srch
voici le truc.. Il compte aussi 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'énoncés, complexité, profondeur de bloc
A sorties graphiques via des graphiques
vous pouvez utiliser le Project Line Counter add-in Dans Visual Studio 2010. Normalement, il ne fonctionne pas avec Visual Studio 2010, mais il le fait avec un serviable .fichier reg d'ici: http://www.onemanmmo.com/index.php?cmd=newsitem&comment=news.1.41.0
j'ai créé un script powershell rapide et sale pour compter les lignes dans une structure de dossiers. Il n'est pas aussi complet que d'autres outils référencé dans d'autres réponses, mais je pense que c'est assez bon pour fournir une comparaison approximative de la taille des fichiers de code par rapport à l'autre dans un projet ou d'une solution.
le script peut être trouvé ici:
essayez neptuner. Il vous donne aussi des choses comme des espaces, des onglets, des lignes de commentaires en plus de LoC. http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip
dans Visual Studio 2015, allez dans le Menu Analyser et sélectionnez "Calculer les paramètres du Code".