Come si contano le righe di codice in una soluzione di Visual Studio?

È possibile trovare il numero di righe di codice in un'intera soluzione? Ho sentito parlare di MZ-Tools , ma esiste un equivalente open source?

Visual Studio 2010 Ultimate ha questo incorporato:

Analizza → Calcola metriche di codice

Ho trovato utile PowerShell per questo. Considero comunque LoC una metrica piuttosto fasulla, quindi non credo che dovrebbe essere richiesto qualcosa di più formale.

Dalla directory di una soluzione piccola:

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

Ciò conterà le righe non vuote in tutti i file .cs e .xaml della soluzione. Per un progetto più ampio, ho appena usato un elenco di estensioni diverso:

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

Perché usare un'intera app quando lo farà una singola riga di comando? :)

Ho usato Ctrl+ Shift+ F. Successivamente, inserisci a \nnella casella di ricerca e abilita la casella delle espressioni regolari. Quindi, nei risultati di ricerca, alla fine della schermata sono indicati il ​​numero di file cercati e le righe di codice trovate.

Puoi usare [^\n\s]\r\nper saltare le righe vuote e solo spaziali (crediti a Zach nei commenti).

Un contatore di linee open source per VS2005, 2003 e 2002 è disponibile qui:

http://www.wndtabs.com/

Qui si discute anche della creazione di un addin VS conteggio delle righe, completo di codice su Codeproject

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

Anche Slick Edit Gadget ha un bel contatore di linee, qui:

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

e Microsoft Visual Studio Team System 2008 include un buon contatore di linee.

Ricorda però:

Misurare l'avanzamento della programmazione mediante righe di codice è come misurare il progresso della costruzione di aeromobili in base al peso. Bill Gates

Ecco un aggiornamento per Visual Studio 2012/2013/2015 per coloro che vogliono fare l'opzione "Trova" (che trovo sia la più semplice): questo RegEx troverà tutte le righe non vuote con diverse esclusioni per fornire i risultati più accurati .

Immettere il seguente RegEx nella casella "Trova". Assicurati di selezionare l'opzione "Usa espressioni regolari". Modificare l'opzione di ricerca su "Progetto corrente" o "Soluzione completa" in base alle proprie esigenze. Ora seleziona "Trova tutto". Nella parte inferiore della finestra Trova risultati , vedrai "Linee corrispondenti", ovvero le righe del conteggio del codice.

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

Questo RegEx esclude i seguenti articoli:

Commenti

// This is a comment

Commenti su più righe (supponendo che le righe siano correttamente commentate con un * davanti a ciascuna riga)

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

XML per Intellisense

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

Commenti HTML:

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

Utilizzando dichiarazioni:

using System;
using System.Web;

Apertura di parentesi graffe:

{

Parentesi graffe di chiusura:

}

Nota: qualsiasi cosa tra le parentesi graffe verrebbe inclusa nella ricerca, ma in questo esempio contano solo 4 righe di codice, anziché 18 righe non vuote effettive:

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

Ho creato questo per darmi un conteggio LOC molto più accurato rispetto ad alcune opzioni precedenti e ho pensato che avrei condiviso. I boss adorano i conteggi di LOC, quindi sono bloccato per un po '. Spero che qualcun altro possa trovare questo utile, fammi sapere se hai domande o hai bisogno di aiuto per farlo funzionare.

Trovato questo suggerimento: LOC con VS Trova e sostituisci

Non un plug-in, tuttavia, se è quello che stai cercando.

cloc è un eccellente commandline , basato su Perl, eseguibile da Windows che spezzerà le righe vuote, le righe commentate e le righe di codice sorgente, raggruppate per formati di file.

Ora non verrà eseguito in modo specifico su un file di soluzione VS, ma può ricorrere attraverso le directory e puoi impostare i filtri del nome file come ritieni opportuno.

Ecco l'output di esempio dalla loro pagina Web:

prompt> cloc perl-5.10.0.tar.gz
    4076 file di testo.
    3883 file unici.                                          
    1521 file ignorati.

http://cloc.sourceforge.net v 1.07 T = 10.0 s (251,0 file / s, 84566,5 righe / s)
-------------------------------------------------- -----------------------------
File di lingua in bianco scala di commenti codice terza generazione. equiv
-------------------------------------------------- -----------------------------
Perl 2052 110356 112521 309778 x 4.00 = 1239112.00
C 135 18718 22862 140483 x 0,77 = 108171,91
Intestazione C / C ++ 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
fare 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
Lotto DOS 11 85 50 322 x 0,63 = 202,86
HTML 1 19 2 98 x 1,90 = 186,20
-------------------------------------------------- -----------------------------
SOMMA: 2510 142085 156406 547174 x 2,84 = 1556285,03
-------------------------------------------------- -----------------------------

La scala equivalente di terza generazione è una stima approssimativa di quanto codice sarebbe necessario in una lingua di terza generazione . Non terribilmente utile, ma comunque interessante.

Le risposte qui sono un po 'obsolete, potrebbero essere rispetto al 2008. Perché nelle versioni più recenti di Visual Studio 2010/2012, questa funzionalità è già integrata. Pertanto, non vi è motivo di utilizzare alcuna estensione o strumento per esso.

Funzione per contare le righe di codice - Calcola metriche. Con esso è possibile calcolare le metriche (LOC, indice di manutenzione, indice ciclomatico, profondità dell'eredità) per ciascun progetto o soluzione.

Basta fare clic destro sulla soluzione o progetto in Esplora soluzioni,

e seleziona "Calcola metriche"

I dati successivi per analisi e aggregazione potrebbero essere importati in Excel. Anche in Excel puoi filtrare le classi generate o altro rumore dalle tue metriche. Queste metriche, incluse le righe di codice LOC, possono essere raccolte anche durante il processo di compilazione e incluse nel report di compilazione

Le espressioni regolari sono cambiate tra VS2010 e 2012, quindi la maggior parte delle soluzioni per espressioni regolari qui non funzionano più

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

Troverà tutte le righe che non sono vuote, non sono solo una singola parentesi ('{' o '}') e non solo un #include o un altro preprocessore.

Usa Ctrl- shift- fe assicurati che le espressioni regolari siano abilitate.

L'espressione regolare corrispondente per VS 2010 e precedenti è

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

In Visual Studio Team System 2008 è possibile eseguire dal menu Analizza -> 'Calcola metriche di codice per soluzione' e ti darà un conteggio di riga dell'intera soluzione (tra le altre cose g )

Per i futuri lettori vorrei consigliare l' estensione DPack per Visual Studio 2010 .

Ha un sacco di utility integrate tra cui un contatore di linee che dice quante righe sono vuote, codice, ecc.

Una soluzione semplice è cercare in tutti i file. Digita "*" mentre usi i caratteri jolly. Che corrisponderebbe a tutte le linee. Alla fine della finestra di ricerca dei risultati dovresti vedere una riga dell'ordinamento:

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

Naturalmente questo non è molto buono per i grandi progetti, poiché tutte le linee vengono elaborate e caricate in memoria per essere disperse nella finestra dei risultati della ricerca.

Riferimento:

• Esempio avanzato

Puoi usare:

• SCLOCCount http://www.dwheeler.com/sloccount/ - Open source
• loc metrics, http://www.locmetrics.com/ - non open source, ma facile da usare

Preferisco OxyProject Metrics VS Addin.

Ovviamente gli strumenti sono più facili, ma mi sento bene farlo in PowerShell :)

Questo script trova tutti i riferimenti .csproj nel file .sln, quindi all'interno di ciascun file csproj individua i file inclusi per la compilazione. Per ogni file incluso per la compilazione crea un oggetto con proprietà: Soluzione, Progetto, File, Linee. Memorizza tutti questi oggetti in un elenco, quindi raggruppa e proietta i dati secondo necessità.

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

Altro semplice strumento per VS2008 (open source): http://www.accendo.sk/Download/SourceStat.zip

Usa l'opzione Menu-> Analizza -> Calcola metriche di codice in Visual Studio 2010 Ultimate.

È possibile utilizzare le metriche del codice di Visual Studio PowerTool 10.0 . È un'utilità della riga di comando che calcola alcune metriche sul codice gestito (incluse le righe di codice). È possibile ottenere un plug-in VS 2010 che porta lo strumento in Visual Studio e lo rende veloce come selezionare la voce di menu e fare clic su "Analizza soluzione".

D'accordo con Ali Parr. L'add-on WndTab Line Counter è un tale strumento. http://www.codeproject.com/KB/macros/linecount.aspx

È anche una buona idea cercare dal sito di download per trovare alcuni strumenti correlati. http://www.cnet.com/1770-5_1-0.html?query=code+counter&tag=srch

Ecco il trucco .. Conta anche il file Js.

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

Puoi usare lo strumento gratuito SourceMonitor

Fornisce molte misure: righe di codice, conteggio delle istruzioni, complessità, profondità del blocco

Ha output grafici tramite grafici

È possibile utilizzare il componente aggiuntivo Project Line Counter in Visual Studio 2010. Normalmente non funziona con Visual Studio 2010, ma funziona con un utile file .reg da qui: http://www.onemanmmo.com/index. php? cmd = NewsItem & comment = news.1.41.0

Ho ideato uno script PowerShell veloce e sporco per contare le linee in una struttura di cartelle. Non è così completo come alcuni degli altri strumenti citati in altre risposte, ma penso che sia abbastanza buono da fornire un confronto approssimativo della dimensione dei file di codice l'uno rispetto all'altro in un progetto o in una soluzione.

Lo script può essere trovato qui:

https://gist.github.com/1674457

Prova nettuno. Ti dà anche cose come spazi, schede, righe di commenti oltre a LoC. http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip

In Visual Studio 2015 vai al menu Analizza e seleziona "Calcola metriche di codice".