it-swarm.com.de

Wie zählen Sie die Codezeilen in einer Visual Studio-Lösung?

Ist es möglich, die Anzahl der Codezeilen in einer gesamten Lösung zu finden? Ich habe von MZ-Tools gehört, aber gibt es ein Open Source-Äquivalent?

749
Fermin

Visual Studio 2010 Ultimate verfügt über diese integrierte Funktion.

Analysieren -> Codemetriken berechnen

471
Herter

Ich habe Powershell nützlich dafür gefunden. Ich halte LoC sowieso für eine ziemlich falsche Metrik, daher glaube ich, dass nichts Formaleres erforderlich sein sollte.

Aus dem Verzeichnis einer kleineren Lösung:

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

Damit werden die nicht leeren Zeilen in allen .cs- und .xaml-Dateien der Lösung gezählt. Für ein größeres Projekt habe ich nur eine andere Erweiterungsliste verwendet:

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

Warum eine gesamte App verwenden, wenn dies über eine einzige Befehlszeile möglich ist? :)

804
Greg D

Ich benutzte Ctrl+Shift+F. Fügen Sie als Nächstes einen \n in das Suchfeld ein und aktivieren Sie das Feld für reguläre Ausdrücke. In den Suchergebnissen wird am Ende des Bildschirms die Anzahl der durchsuchten Dateien und die Anzahl der gefundenen Codezeilen angezeigt.

341

Ein Open Source Line Counter für VS2005, 2003 und 2002 ist hier verfügbar:

http://www.wndtabs.com/

Außerdem wird hier die Erstellung eines VS-Add-Ins für die Zeilenzählung mit Code für Codeproject erörtert

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

Auch Slick Edit-Gadgets haben einen Nizza-Zeilenzähler, hier:

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

microsoft Visual Studio Team System 2008 enthält einen guten Zeilenzähler.

Denken Sie jedoch daran:

Das Messen des Programmierfortschritts anhand von Codezeilen entspricht dem Messen des Flugzeugbaufortschritts anhand des Gewichts. Bill Gates

218
Ali Parr

Fanden diesen Tipp: LOC mit VS Suchen und Ersetzen

Kein Plugin, wenn Sie danach suchen.

80
Mads Andersen

Hier ist ein Update für Visual Studio 2012/2013/2015 für diejenigen, die die Option "Suchen" ausführen möchten (die meiner Meinung nach am einfachsten ist): Diese RegEx findet alle nicht leeren Zeilen mit mehreren Ausschlüssen, um die genauesten Ergebnisse zu erzielen .

Geben Sie den folgenden RegEx in das Feld "Suchen" ein. Stellen Sie sicher, dass Sie die Option "Reguläre Ausdrücke verwenden" auswählen. Ändern Sie die Suchoption je nach Bedarf in "Aktuelles Projekt" oder "Gesamte Lösung". Wählen Sie nun "Alle suchen". Am unteren Rand des Fensters Suchergebnisse sehen Sie "Übereinstimmende Zeilen", die die Anzahl der Codezeilen darstellen.


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

Diese RegEx schließt die folgenden Elemente aus:


Bemerkungen

// This is a comment

Mehrzeilige Kommentare (vorausgesetzt, die Zeilen sind korrekt mit einem * vor jeder Zeile kommentiert)

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

XML für Intellisense

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

HTML-Kommentare:

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

Anweisungen verwenden:

using System;
using System.Web;

Lockige Klammern öffnen:

{

Geschweifte Klammern schließen:

}

Hinweis: Alles zwischen den geschweiften Klammern würde in die Suche einbezogen, aber in diesem Beispiel würden nur 4 Codezeilen anstelle von 18 tatsächlichen nicht leeren Zeilen gezählt:

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

Ich habe dies erstellt, um eine viel genauere LOC-Zählung als bei einigen früheren Optionen zu erhalten, und dachte, ich würde sie teilen. Die Chefs lieben LOC zählt, also bleibe ich eine Weile dabei. Ich hoffe, jemand anderes kann dies hilfreich finden. Lassen Sie mich wissen, wenn Sie Fragen haben oder Hilfe benötigen, damit es funktioniert.

75
Howard Renollet

cloc ist eine exzellente, auf Perl basierende, auf Windows ausführbare Befehlszeile, die die nach Dateiformaten gruppierten Leerzeilen, Kommentarzeilen und Quellcodezeilen aufteilt.

Jetzt wird es nicht speziell für eine VS-Lösungsdatei ausgeführt, sondern kann Verzeichnisse durchlaufen und Sie können nach Belieben Dateinamenfilter einrichten.

Hier ist die Beispielausgabe von ihrer Webseite:

 
 Eingabeaufforderung> cloc Perl-5.10.0.tar.gz 
 4076 Textdateien. 
 3883 eindeutige Dateien. 
 1521 Dateien ignoriert. 
 
 Http://cloc.sourceforge.net v 1.07 T = 10.0 s (251.0 Dateien/s, 84566.5 Zeilen/s) 
 -------------------------------------------------- ----------------------------- 
 Sprachdateien leer Kommentar Code Skala 3. Gen. äquiv 
 ---------------------------------------- ----------------------------------- 
 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 
 Ergibt 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-Charge 11 85 50 322 x 0,63 = 202,86 
 HTML 1 19 2 98 x 1,90 = 186,20 
 ------------------------ -------------------------------------------------- ----- 
 SUMME: 2510 142085 156406 547174 x 2.84 = 1556285.03 
 ------------------------- -------------------------------------------------- ---- 
 

Die äquivalente Skala der dritten Generation ist eine grobe Schätzung der Menge an Code, die in einer Sprache der dritten Generation benötigt würde. Nicht besonders nützlich, aber trotzdem interessant.

61
Mark Rushakoff

Die Antworten hier sind etwas veraltet und stammen möglicherweise aus dem Jahr 2008. Da diese Funktion in neueren Visual Studio-Versionen 2010/2012 bereits integriert ist. Daher gibt es keinen Grund, eine Erweiterung oder Tools dafür zu verwenden.

Funktion zum Zählen von Codezeilen - Metriken berechnen. Damit können Sie Ihre Metriken (LOC, Wartungsindex, Zyklomatischer Index, Vererbungstiefe) für jedes Projekt oder jede Lösung berechnen.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe oder das Projekt.

enter image description here

und wählen Sie "Metriken berechnen"

enter image description here

Spätere Daten zur Analyse und Aggregation können in Excel importiert werden. Auch in Excel können Sie generierte Klassen oder anderes Rauschen aus Ihren Metriken herausfiltern. Diese Metriken, einschließlich Codezeilen LOC, können auch während des Erstellungsprozesses erfasst und in den Erstellungsbericht aufgenommen werden

42
Regfor

Reguläre Ausdrücke haben sich zwischen VS2010 und 2012 geändert, sodass die meisten Lösungen für reguläre Ausdrücke hier nicht mehr funktionieren

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

Findet alle Zeilen, die nicht leer sind, nicht nur eine einzelne Klammer ('{' oder '}') und nicht nur ein # include oder ein anderer Präprozessor.

Verwenden Ctrl-shift-f und stellen Sie sicher, dass reguläre Ausdrücke aktiviert sind.

Der entsprechende reguläre Ausdruck für VS 2010 und älter ist

^~(:[email protected]//.+)~(:[email protected]\{:[email protected])~(:[email protected]\}:[email protected])~(:[email protected]/#).+
28
user2711915

In Visual Studio Team System 2008 können Sie über das Menü Analysieren -> Codemetriken für Lösung berechnen eine Zeilenzählung Ihrer gesamten Lösung anzeigen (unter anderem g).

19

Für zukünftige Leser würde ich gerne die DPack-Erweiterung für Visual Studio 201 empfehlen.

Es gibt eine Menge Dienstprogramme, einschließlich eines Zeilenzählers, der angibt, wie viele Zeilen leer sind, wie viel Code usw.

17
Ashley Davies

Eine einfache Lösung besteht darin, in allen Dateien zu suchen. Geben Sie "*" ein, während Sie Platzhalter verwenden. Welches würde für alle Zeilen passen. Am Ende des Fensters mit den Suchergebnissen sollte eine Zeile der folgenden Art angezeigt werden:

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

Dies ist natürlich nicht sehr gut für große Projekte, da alle Zeilen bearbeitet und in den Speicher geladen werden, um im Fenster mit den Suchergebnissen angezeigt zu werden.

Hinweis:

11
Sogartar

Du könntest benutzen:

9
Edward Wilde

Ich bevorzuge OxyProject Metrics VS Addin.

5

Natürlich sind Werkzeuge einfacher, aber ich finde es cool, dies in Powershell zu tun :)

Dieses Skript findet alle .csproj-Referenzen in der .sln-Datei und sucht dann in jeder csproj-Datei nach Dateien, die zum Kompilieren enthalten sind. Für jede zur Kompilierung enthaltene Datei wird ein Objekt mit den folgenden Eigenschaften erstellt: Projektmappe, Projekt, Datei, Linien. Alle diese Objekte werden in einer Liste gespeichert. Anschließend werden die Daten nach Bedarf gruppiert und projiziert.

#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}
4
anakic

Anderes einfaches Tool für VS2008 (Open Source): http://www.accendo.sk/Download/SourceStat.Zip

3
LiborBes

Verwenden Sie in Visual Studio 2010 Ultimate die Option Menü-> Analysieren -> Codemetriken berechnen.

3
sunil

Sie können das Visual Studio Code Metrics PowerTool 10. verwenden. Es ist ein Befehlszeilendienstprogramm, das einige Metriken für verwalteten Code (einschließlich Codezeilen) berechnet. Sie können ein VS 2010-Plug-in herunterladen, das bringt das Tool in Visual Studio und es so schnell wie das Auswählen des Menüelements und das Klicken auf "Lösung analysieren" macht.

3
Travis
2

Sie können das kostenlose Tool SourceMonitor verwenden

Ergibt eine Vielzahl von Maßnahmen: Codezeilen, Anweisungsanzahl, Komplexität, Blocktiefe

Hat grafische Ausgaben über Diagramme

2

Stimme ALi Parr zu. Das WndTab Line Counter Addin ist ein solches Tool. http://www.codeproject.com/KB/macros/linecount.aspx

Es ist auch eine gute Idee, von der Download-Site nach verwandten Tools zu suchen. http://www.cnet.com/1770-5_1-0.html?query=code+counter&tag=srch

2
fastyond

Ich hatte ein schnelles und schmutziges Powershell-Skript zum Zählen von Zeilen in einer Ordnerstruktur. Es ist nicht annähernd so umfassend wie einige der anderen Tools, auf die in anderen Antworten verwiesen wird, aber ich denke, es ist gut genug, um einen groben Vergleich der Größe von Codedateien in einem Projekt oder einer Lösung im Verhältnis zueinander zu ermöglichen.

Das Skript finden Sie hier:

https://Gist.github.com/1674457

1
Jesse Taber

Sie können das Projektzeilenzähler-Add-In in Visual Studio 2010 verwenden. Normalerweise funktioniert es nicht mit Visual Studio 2010, aber mit einer hilfreichen .reg-Datei von hier: http: //www.onemanmmo. com/index.php? cmd = newsitem & comment = news.1.41.

1
Robert Basler

Gehen Sie in Visual Studio 2015 zum Menü "Analysieren" und wählen Sie "Codemetriken berechnen".

0
Atters

Versuchen Sie es mit Neptuner. Es gibt Ihnen auch Dinge wie Leerzeichen, Tabulatoren, Kommentarzeilen zusätzlich zu LoC. http://neptuner.googlecode.com/files/neptuner_0_30_windows.Zip

0
sonofdelphi