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 ermitteln? Ich habe von MZ-Tools gehört , aber gibt es ein Open Source-Äquivalent?

In Visual Studio 2010 Ultimate ist Folgendes integriert:

Analysieren → Codemetriken berechnen

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? :) :)

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).

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

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.

Diesen Tipp gefunden: LOC mit VS Suchen und ersetzen

Kein Plugin, wenn Sie danach suchen.

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.

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.

und wählen Sie "Metriken berechnen"

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

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@/#).+

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 ).

Für zukünftige Leser möchte ich die DPack-Erweiterung für Visual Studio 2010 empfehlen .

Es sind eine Reihe von Dienstprogrammen integriert, darunter ein Zeilenzähler, der angibt, wie viele Zeilen leer sind, Code usw.

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:

• Erweitertes Beispiel

Du könntest benutzen:

• SCLOCCount http://www.dwheeler.com/sloccount/ - Open Source
• Loc-Metriken, http://www.locmetrics.com/ - nicht Open Source, aber einfach zu bedienen

Ich bevorzuge OxyProject Metrics VS Addin.

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}

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

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

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

Stimmen Sie mit Ali Parr überein. 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 zu suchen, um ein verwandtes Tool zu finden. http://www.cnet.com/1770-5_1-0.html?query=code+counter&tag=srch

Hier ist der Trick. Er zählt auch die Js-Datei.

http://www.spoiledtechie.com/post/2011/11/22/How-To-Count-Lines-of-Code-in-Visual-Studio.aspx

Sie können das kostenlose Tool SourceMonitor verwenden

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

Hat grafische Ausgaben über Diagramme

Sie können das Add-In "Projektzeilenzähler" 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.0

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

Versuchen Sie es mit Neptuner. Zusätzlich zu LoC erhalten Sie auch Leerzeichen, Tabulatoren und Kommentarzeilen. http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip

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