Comment comptez-vous les lignes de code dans une solution Visual Studio?
https://stackoverflow.com/questions/1244729
-
12-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Est-il possible de trouver le nombre de lignes de code dans une solution complète? Je l'ai entendu parler de MZ-outils , mais est-il un équivalent open source?
La solution
Visual Studio 2010 Ultimate a cette intégré.
Analyse -> Calculer le code métrique
Autres conseils
Je l'ai trouvé powershell utile pour cela. Je considère LoC être une mesure assez fausse de toute façon, donc je ne croirais pas quelque chose de plus formel nécessaire.
à partir du répertoire une solution assez petite:
PS C:\Path> (gci -include *.cs,*.xaml -recurse | select-string .).Count
8396
PS C:\Path>
qui comptera les lignes non-vides dans tous les .cs de la solution et les fichiers XAML. Pour un projet plus vaste, 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 une application entière lorsqu'une seule ligne de commande va le faire? :)
je Ctrl + Maj + F . Ensuite, mettre un \n dans la zone de recherche et activer boîte expressions régulières. Puis, dans les résultats de trouver, à la fin de l'écran sont le nombre de fichiers et recherche de lignes de code trouvé.
Un compteur de lignes open source pour VS2005, 2003 et 2002 est disponible ici:
Il est aussi question de créer une ligne de comptage VS Addin, avec code sur CodeProject, ici
http://www.codeproject.com/KB/macros/LineCounterAddin.aspx
En outre Slick Modifier gadgets ont une belle ligne contre, ici:
http://www.slickedit.com/products/slickedit
et Microsoft Visual Studio Team système 2008 comprend un bon compteur de lignes.
Rappelez-vous que:
La mesure des progrès de la programmation par des lignes de code est comme la mesure des progrès de la construction aéronautique en poids. Bill Gates
à cet astuce: LOC avec VS Rechercher et remplacer
Pas un plugin bien si c'est ce que vous recherchez.
Voici une mise à jour pour Visual Studio 2012/2013/2015 pour ceux qui veulent faire l'option « Rechercher » (que je trouve être le plus facile): Ce RegEx trouverez toutes les lignes non-vides avec plusieurs exclusions pour donner la des résultats plus précis.
Entrez les RegEx suivantes dans la boîte « Rechercher ». faire s'il vous plaît assurez-vous de sélectionner l'option « Utiliser les expressions régulières ». Changer l'option de recherche soit « projet actuel » ou « solution complète » en fonction de vos besoins. Maintenant, sélectionnez « Trouver tous ». Au bas de la Rechercher Résultats fenêtre, vous verrez « Les lignes correspondantes » qui est les lignes de comptage de code.
^(?!(\s*\*))(?!(\s*\-\-\>))(?!(\s*\<\!\-\-))(?!(\s*\n))(?!(\s*\*\/))(?!(\s*\/\*))(?!(\s*\/\/\/))(?!(\s*\/\/))(?!(\s*\}))(?!(\s*\{))(?!(\s(using))).*$
Cette RegEx exclut les éléments suivants:
Commentaires
// This is a comment
multi-lignes (en supposant que les lignes sont commentées correctement avec un * devant chaque ligne)
/* I am a
* multi-line
* comment */
XML pour IntelliSense
/// <summary>
/// I'm a class description for Intellisense
/// </summary>
HTML Commentaires:
<!-- I am a HTML Comment -->
Utilisation d'instructions:
using System;
using System.Web;
Ouverture accolades:
{
Fermeture des accolades:
}
Remarque: quoi que ce soit entre les accolades serait inclus dans la recherche, mais dans cet exemple seulement 4 lignes de code compterait, au lieu de 18 lignes non-vides réels:
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 je pensais partager. Les patrons aiment compte LOC, donc je suis coincé avec elle pendant un certain temps. J'espère que quelqu'un d'autre peut-il été utile, laissez-moi savoir si vous avez des questions ou avez besoin d'aide pour que cela fonctionne.
cloc est un excellent commandline, basé sur Perl, Windows exécutable qui décomposent les lignes vides , a commenté lignes et lignes de source de code, regroupés par formats de fichier.
Maintenant, il ne fonctionnera pas spécifiquement sur un fichier de solution VS, mais il peut récursivité dans les répertoires, et vous pouvez définir 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 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
-------------------------------------------------------------------------------
La troisième génération échelle équivalente est une estimation approximative de la façon dont beaucoup de code, il faudrait dans un langue . Pas très utile, mais intéressant quand même.
Les réponses sont ici un peu à jour, peut être de 2008 en fonction du temps. Parce que 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 pour compter les lignes de code - Calculer des mesures. Avec elle, vous pouvez calculer vos paramètres (LOC, index Maintaince, index Cyclomatic, profondeur de inheritence) pour chaque projet ou d'une solution.
Il suffit de faire un clic droit sur la solution ou d'un projet dans l'Explorateur de solutions,
et sélectionnez "Calculer les paramètres"
données ultérieures pour l'analyse et l'agrégation pourraient être importées dans Excel. Toujours dans Excel, vous pouvez filtrer les classes générées, ou autres bruits de vos paramètres. Ces mesures, y compris les lignes de code LOC pourraient être recueillies aussi au cours du processus de construction, et inclus dans le rapport de construction
Les expressions régulières ont changé entre VS2010 et 2012, de sorte que la plupart des solutions d'expressions régulières ici ne fonctionnent plus
(^(?!(\s*//.+)))+(^(?!(#.+)))+(^(?!(\s*\{.+)))+(^(?!(\s*\}.+)))+(^(?!(\s*\r?$)))+
Trouverez toutes les lignes qui ne sont pas vides, ne sont pas seulement un seul support ( « { » ou « } ») et non pas seulement un #include ou autre préprocesseur.
Utilisez Ctrl - déplacer -. f et assurez-vous que les expressions régulières sont activées
L'expression régulière correspondant pour VS 2010 et plus est
^~(:Wh@//.+)~(:Wh@\{:Wh@)~(:Wh@\}:Wh@)~(:Wh@/#).+
Dans Visual Studio Team System 2008, vous pouvez le faire à partir du menu Analyse -> « Calculer le code paramètres pour la solution » et il vous donnera un nombre de lignes de votre solution complète (entre autres g )
Pour les futurs lecteurs, j'aimerais conseiller le DPACK l'extension pour Visual studio 2010 .
Il a une charge des services publics construits en comprenant un compteur de ligne qui dit combien de lignes sont vides, le code, et etc.
Une solution simple consiste à rechercher dans tous les fichiers. Tapez « * » tout en utilisant des caractères génériques. Correspondre à toutes les lignes. A la fin de la fenêtre de résultats de recherche que vous avez 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, étant donné que toutes les lignes sont Mached et chargées en mémoire à dispayed à la fenêtre des résultats de la trouver.
Référence:
- Exemple avancée
Vous pouvez utiliser:
- http://www.dwheeler.com/sloccount/ - open source mesures
- loc, http://www.locmetrics.com/ - pas open source, mais facile à utiliser
Je préfère OxyProject Metrics VS Addin.
Il est évident que les outils sont plus faciles, mais je me sens frais le faire dans Powershell:)
Ce script trouve toutes les références de .csproj dans le fichier .sln, puis dans chaque fichier csproj localise les fichiers inclus pour la compilation. Pour chaque fichier qui est inclus pour la compilation crée un objet avec des propriétés: Solution, Projet, fichier, lignes. Il stocke tous ces objets dans une liste, puis les groupes et projette les données nécessaires.
#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 Menu-> Analyser -.> Option calculer le code Metrics dans Visual Studio 2010 Ultimate
Vous pouvez utiliser le code Visual Studio Metrics PowerTool 10.0 . Il est un utilitaire de ligne de commande qui calcule quelques mesures sur le code managé pour vous (y compris les lignes de code). Vous pouvez obtenir un plug-in VS 2010 que apporte l'outil dans Visual Studio , et le rend aussi rapide que sélectionner l'élément de menu et cliquez sur « Analyser la solution. »
D'accord avec Ali Parr. La ligne WndTab contre Addin est un outil. http://www.codeproject.com/KB/macros/linecount.aspx
Il est aussi une bonne idée de recherche du site de téléchargement pour trouver un outil connexe. http://www.cnet.com/1770-5_1 -0.html? query = Code + compteur & tag = srch
Voici le Trick .. Il compte également le fichier Js.
Vous pouvez utiliser l'outil gratuit SourceMonitor donne beaucoup de mesures: lignes de code, Déclaration Count, complexité, profondeur bloc possède des sorties graphiques via les cartes
Vous pouvez utiliser le module complémentaire en ligne Project Counter dans Visual Studio 2010. Normalement, il ne fonctionne pas avec Visual Studio 2010, mais il le fait avec un fichier .reg utile d'ici: http://www.onemanmmo.com/index.php?cmd=newsitem&comment=news.1.41.0
Je suis venu avec un script Powershell rapide et sale pour le comptage des lignes dans une structure de dossiers. Il est loin d'être aussi complet présenté comme certains des autres outils mentionné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 par rapport à l'autre dans un projet ou d'une solution.
se trouve Le script ici:
Essayez NEPTUNER. Il vous donne également des trucs 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 aller au menu Analyse et sélectionnez "Calculer code Metrics".
