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

800

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

Fermin
quelle
24
Ich bin damit einverstanden, dass es nicht viel hilft, aber wenn das Management danach fragt ...
Fermin
33
LoC ist einfach eine Metrik und in zwei Fällen besonders interessant: 1) um eine Vorstellung davon zu bekommen, wie groß die Codebasis ist, dh wenn Sie einem neuen Team beitreten, 2) um Ihren Fortschritt zu messen, wenn Sie versuchen, Ihre Codebasis kompakter zu gestalten
Piotr Owsiak
191
Einige Leute hier sagen, dass das Zählen von Codezeilen nutzlos ist, ohne darüber nachzudenken. Dies ist sehr nützlich, da es sich um eine Metrik handelt, die im Allgemeinen minimiert werden sollte. Dies ist eine einfache Methode, um die Komplexität der Lösung (nicht die Effizienz) zu messen. Wenn bekannt ist, dass das Problem einfach ist, ist die Qualität im Allgemeinen umso geringer, je mehr Codezeilen vorhanden sind. Eine andere Sache ist, warum die Leute sich die Mühe machen zu antworten, wenn es nur darum geht zu sagen, dass die Frage schlecht ist. Was würden Sie denken, wenn ein Lehrer Ihnen sagen würde, dass Ihre Frage einfach nicht gestellt werden sollte?
77
In VS2010 gibt es ein integriertes Tool, das auch alle Codezeilen und andere Werte zählt: Gehen Sie zu Ansicht -> Andere Fenster -> Ergebnisse der Codemetriken. Klicken Sie auf eine kleine Schaltfläche in der Ecke, die wie ein Kalender aussieht. Klicken Sie darauf. In der QuickInfo sollte "Code-Metriken für Soulution berechnen" angezeigt werden, und VS soll dies tun.
user959631
64
Die Person muss Ihnen nicht immer sagen, warum sie Code zählen möchte. Wenn die Frage einfach gestellt wird, ist der Fall, warum, irrelevant. Beantworten Sie einfach seine Frage. Ich hasse, dass. Es gibt Zeiten, in denen Sie sich fragen müssen, warum, wenn Sie dies eindeutig müssen, und dann Zeiten, in denen Sie dies nicht tun (wenn Sie persönlich keinen Bedarf sehen ... und das Poster nur arrogant belästigen).
PositiveGuy

Antworten:

525

In Visual Studio 2010 Ultimate ist Folgendes integriert:

Analysieren → Codemetriken berechnen

Herter
quelle
12
Ultimate und Premium, denke ich
Stefan Dragnev
39
Warnung: Dies führt neben der einfachen Zeilenzählung noch viele andere Dinge aus. Außerdem werden "Wartbarkeitsindex", "Zyklomatische Komplexität", "Vererbungstiefe" und "Klassenkopplung" aufgelistet, die alle ziemlich kompliziert zu berechnen sind, und Sie können die Metriken nicht nur für einen Teil davon ausführen. Dies bedeutet, dass Sie, wenn Ihre Codebasis besonders groß ist, möglicherweise stundenlang darauf warten. Wenn Sie nur die Anzahl der Zeilen möchten, gibt es viel schnellere Lösungen.
Darrel Hoffman
4
auch auf vs2012 ultimative =)
oCcSking
9
VS 2013 hat Analyse -> Code-Metriken berechnen
Dinesh Rajan
42
Schade, dass dies mit nativen C ++ - Projekten nicht funktioniert (zumindest nicht in VS2013).
Cameron
844

Ich habe Powershell dafür nützlich gefunden . Ich halte LoC sowieso für eine ziemlich falsche Metrik, daher glaube ich nicht, dass etwas 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>

Dadurch 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 ganze App verwenden, wenn eine einzige Befehlszeile dies ausführt? :) :)

Greg D.
quelle
19
(Das einzige Mal, dass ich jemals gebeten wurde, die Anzahl der Leitungen zu liefern, war, als das obere Management herausfand, wie viel Zeit es dauern würde, alle unsere Produkte nach Übersee zu migrieren, damit sie unseren inländischen Standort schließen können.)
Greg D
8
(Ja, dies schließt codegene Dateien und Kommentare ein. Nein, das stört mich nicht. Designer, gen'd Code und Kommentare müssen ebenfalls gepflegt werden.)
Greg D
27
sehr schön, völlig vergessen über Powershell. es sollte Standardersatz für cmd werden
lubos hasko
4
Ausgezeichnet! Ihr abschließender Kommentar fasst es wirklich zusammen, es ist eine triviale Aufgabe. Warum also ein nicht triviales Tool verwenden? Obwohl ich wirklich denke, dass es in allen Versionen von VS enthalten sein sollte.
Sune Rievers
13
Wenn Sie die für die XAML generierten Sicherungsdateien ausschließen möchten, können Sie einfach einen -exclude-Schalter hinzufügen:(dir -exclude *.g.cs -include *.cs,*.xaml -recurse | select-string .).Count
EZ Hart
349

Ich habe Ctrl+ Shift+ benutzt F. Geben Sie als Nächstes ein \nin das Suchfeld ein und aktivieren Sie das Feld für reguläre Ausdrücke. In den Suchergebnissen werden am Ende des Bildschirms die Anzahl der durchsuchten Dateien und die gefundenen Codezeilen angezeigt.

Sie können [^\n\s]\r\nleere und nur Leerzeichen überspringen (Credits an Zach in den Kommentaren).

NicolásKittsteiner
quelle
16
Diese Lösung enthält fälschlicherweise Leerzeilen, Kommentare, Dokumentationen und geteilte Anweisungen. Für viele Anwendungen sollten diese nicht als Codezeilen gelten.
Jay Baxter
1
Obwohl es etwas ungenau ist (wenn Sie tatsächlich \ n in Ihrem Code verwenden, wird diese Zeile doppelt gezählt), ist es dennoch die beste Antwort, wenn Sie ein ROM mit Codezeilen ohne ein Tool eines Drittanbieters benötigen
Joseph Duty
1
Sie können auch einen bestimmten Dateityp auswählen, indem Sie eine Options- Look at these file types:Dropdown-Liste unter dem auswählen enable regular expressions box.
Moshii
1
Funktioniert für sehr kleine Projekte. Wenn Sie über 100 Millionen Codezeilen verfügen, dauert dies einige Zeit.
Sumpf
11
[^\n\s]\r\nÜberspringt leere Zeilen, auch mit Leerzeichen.
Zach Mierzejewski
219

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

http://www.wndtabs.com/

Es wird auch diskutiert, hier ein VS-Add-In für die Zeilenzählung mit Code in Codeproject zu erstellen

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

Auch Slick Edit Gadgets haben hier einen schönen Zeilenzähler:

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

und 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 nach Gewicht. Bill Gates

Ali Parr
quelle
1
Oft ist das Zählen von Codezeilen Just Plain Silly, und Quantität bedeutet nicht Qualität. Ein riesiges Team, das einen Dreamliner in die Luft bringt, ist jedoch eine ganz andere Leistung als die Einführung des Ultralites, den ich im Alleingang in meiner Garage gebaut habe. Und wenn Sie über die Anzahl der Codezeilen in Windows nachdenken, hat Mr. Bill dies vielleicht anders gemeint, als es normalerweise angenommen wird ...?
UnconditionallyReinstateMonica
18
Keines davon scheint auf Visual Studio 2010 zuzutreffen, und der Slickedit-Link ist unterbrochen.
MGOwen
57
Sie finden die LOC-Funktion in Visual Studio 2010 Ultimate unter "Analyse> Codemetriken". Ich hoffe, ich habe sie richtig übersetzt. Ich habe die deutsche Version. Dort ist es "Analysieren"> "Codemetriken erhöhen"
OneWorld
2
Für Visual Studio 2012 finden Sie die LoC-Metrik unter ANALYZE> Code-Metriken für Lösung
berechnen
2
Außerdem enthält VS2012 diese Funktion sowohl in der Ultimate- als auch in der Premium-Edition (und jetzt auch in Professional).
SWalters
81

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 das folgende 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 finden". Am unteren Rand des Fensters " Ergebnisse suchen" sehen Sie "Übereinstimmende Zeilen", dh die Anzahl der Codezeilen.


^(?!(\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 -->

Verwenden von Anweisungen:

using System;
using System.Web;

Öffnen von geschweiften Klammern:

{

Geschlossene 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 zählen:

        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 einige vorherige Optionen zu erhalten, und dachte, ich würde sie teilen. Die Chefs lieben LOC-Zählungen, 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.

Howard Renollet
quelle
18
Ich liebe die Gegenstimme ohne Kommentar. Dies sollte nicht erlaubt sein. Was ist mit meiner Lösung funktioniert nicht ??? Die Stimmen interessieren mich nicht einmal, ich wollte nur ein Update für VS2012-2013-Benutzer veröffentlichen.
Howard Renollet
Es ist schwierig, den gesamten generierten Code (AssemblyInfo usw.) herauszufiltern. Daher sollte die Analyse / Berechnung von Codemetriken bevorzugt werden.
MKesper
4
Gute Arbeit, aber bitte erwähnen Sie das Kontrollkästchen " Regulären Ausdruck verwenden" im Abschnitt " Suchoptionen ". Es macht es viel einfacher
Gogutz
@MKesper ABER DAS FUNKTIONIERT NICHT FÜR C ++
d7samurai
Eine einfachere Version, wenn weder XML noch HTML ... ^ (? ([^ \ R \ n]) \ s) * [^ \ s +? /] + [^ \ N] * $.
LastBlow
80

Diesen Tipp gefunden: LOC mit VS Suchen und ersetzen

Kein Plugin, wenn Sie danach suchen.

Mads Andersen
quelle
Ich liebe diesen, aber ich glaube, ich habe dort einen kleinen Fehler im Ausdruck gefunden. Für VB.Net sollte es ^ ~ (: Wh @ ') ~ (: Wh @ \ #) sein. + Und für C # denke ich ^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #). + Auf diese Weise werden leere Kommentarzeilen und Compiler-Anweisungen ordnungsgemäß behandelt. Mit VB.NET hat es sowieso besser funktioniert, und C # habe ich nicht getestet.
user12861
^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #) ~ (: Wh @ $). + Endete Als ich besser für C # arbeitete, bekam ich einige Zeilen, die nur aus Leerzeichen bestanden.
user12861
Zählt es nicht auch alle kommentierten Zeilen? Nur Zeilen CODE bitte!
HydPhani
4
Hier ist eine, die ich erstellt habe und die in VS2012 funktioniert (die veröffentlichte Version ist ab 2010 veraltet) und nur Codezeilen zählt. Es schließt alle Kommentare aus, die Direktiven, geschweifte Klammern, XML-Direktiven, Leerzeilen usw. verwenden, um nur einen echten Code zu erhalten: ^ (?! (\ S **)) (?! (\ S * \ - \ - \>)) (?! (\ s * \ <\! \ - \ -)) (?! (\ s * \ n)) (?! (\ s ** \ /)) (?! (\ s * \ / *)) (?! (\ s * \ / \ / \ /)) (?! (\ s * \ / \ /)) (?! (\ s * \})) (? ! (\ s * \ {)) (?! (\ s (using))). * $
Howard Renollet
65

cloc ist eine ausgezeichnete Perl-basierte Windows-ausführbare Befehlszeile , die Leerzeilen, kommentierte Zeilen und Quellcodezeilen nach Dateiformaten gruppiert.

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

Hier ist die Beispielausgabe von ihrer Webseite:

prompt> cloc perl-5.10.0.tar.gz
    4076 Textdateien.
    3883 eindeutige Dateien.                                          
    1521 Dateien werden ignoriert.

http://cloc.sourceforge.net v 1.07 T = 10.0 s (251.0 Dateien / s, 84566.5 Zeilen / s)
-------------------------------------------------- -----------------------------
Sprachdateien leere 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
machen 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-Stapel 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, wie viel Code in einer Sprache der dritten Generation benötigt wird . Nicht besonders nützlich, aber trotzdem interessant.

Mark Rushakoff
quelle
1
Das ist großartig und super einfach zu bedienen. Viel einfacher als die Find / Replace-Lösungen und klarer als die VS Code Metrics-Option. Nur choco install clocund dann cloc .in Ihrer Lösung dir. Job erledigt!
Rory
1
Ich habe Windows EXE von der CLOC-Website heruntergeladen und in meinem Projektordner für die Visual Studio 2017-Website ausgeführt. Lief wie am Schnürchen. Ich mag die Option --by-file-by-lang, mit der die Zeilenanzahl pro Datei und Sprache aufgelistet wird, sortiert vom größten zum kleinsten.
Humbads
42

Die Antworten hier sind etwas veraltet und stammen möglicherweise aus der Zeit von 2008. In neueren Visual Studio-Versionen 2010/2012 ist diese Funktion bereits integriert. Daher gibt es keinen Grund, Erweiterungen 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 Lösung oder Projekt.

Geben Sie hier die Bildbeschreibung ein

und wählen Sie "Metriken berechnen"

Geben Sie hier die Bildbeschreibung ein

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

Regfor
quelle
2
Visual Studio 2010 verfügt auch über diese Metriken. Eigentlich nichts Neues in VS2012.
Mike Chaliy
1
Ja, aber die Antworten hier stammen aus der Zeit von vs 2008 und sind etwas veraltet. Warum sollten Sie etwas verwenden oder eine Erweiterung installieren, wenn es sich um eine integrierte Funktion handelt? Und selbst es ist keine neue Funktion, von der viele Menschen nichts wissen.
Regfor
@MikeChaliy Vielleicht hat Sie der zweite Einführungssatz verwirrt, deshalb habe ich ihn ein wenig umgeschrieben, um solche Verwirrung zu vermeiden.
Regfor
Ich habe eine n-Layer-Lösung, die aber diesen Fehler anzeigt: "Das Ziel eines Aufrufs hat eine Ausnahme ausgelöst." Warum?
user197508
5
Dies sind keine Codezeilen, sondern kompilierte Zeilen (dh nachdem sie in IL umgewandelt wurden). Ich denke, Fermin suchte nach vorkompilierten Zeilen.
Mikeschuld
29

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 einen anderen Präprozessor.

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

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

^~(:Wh@//.+)~(:Wh@\{:Wh@)~(:Wh@\}:Wh@)~(:Wh@/#).+
user2711915
quelle
19

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

Christopher Klein
quelle
12
Visual Studio Team System 2008 kann nicht verwalteten Code nicht zählen. ;)
Christian
11

Eine einfache Lösung besteht darin, alle Dateien zu durchsuchen. Geben Sie "*" ein, während Sie Platzhalter verwenden. Welches würde alle Zeilen passen. Am Ende des Fensters "Ergebnisse finden" 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 Suchergebnisfenster angezeigt zu werden.

Referenz:

Sogartar
quelle
5

Ich bevorzuge OxyProject Metrics VS Addin.

Selçuk Öztürk
quelle
4

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 zur Kompilierung enthalten sind. Für jede Datei, die zum Kompilieren enthalten ist, wird ein Objekt mit den folgenden Eigenschaften erstellt: Lösung, Projekt, Datei, Linien. Es speichert alle diese Objekte in einer Liste und gruppiert und projiziert die Daten nach Bedarf.

#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}
anakisch
quelle
3

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

sunil
quelle
2

Sie können das kostenlose Tool SourceMonitor verwenden

Gibt viele Maßnahmen: Codezeilen, Anweisungsanzahl, Komplexität, Blocktiefe

Hat grafische Ausgaben über Diagramme

Hovhannes Hakobyan
quelle
1

Ich habe ein schnelles und schmutziges Powershell-Skript zum Zählen von Zeilen in einer Ordnerstruktur entwickelt. 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 im Verhältnis zueinander in einem Projekt oder einer Lösung zu ermöglichen.

Das Skript finden Sie hier:

https://gist.github.com/1674457

Jesse Taber
quelle
0

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

Atters
quelle