Jak policzyć wiersze kodu w rozwiązaniu Visual Studio?

Czy można znaleźć liczbę wierszy kodu w całym rozwiązaniu? Słyszałem o MZ-Tools , ale czy istnieje odpowiednik open source?

Program Visual Studio 2010 Ultimate ma następujące funkcje:

Analiza → Oblicz metryki kodu

Uważam, że PowerShell jest do tego przydatny. I tak uważam LoC za dość fałszywą miarę, więc nie uważam, że należy wymagać czegoś bardziej formalnego.

Z katalogu małego rozwiązania:

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

To policzy niepuste linie we wszystkich plikach .cs i .xaml rozwiązania. W przypadku większego projektu użyłem innej listy rozszerzeń:

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

Po co korzystać z całej aplikacji, gdy zrobi to jeden wiersz poleceń? :)

Użyłem Ctrl+ Shift+ F. Następnie wstaw a \nw polu wyszukiwania i włącz pole wyrażeń regularnych. Następnie w wynikach wyszukiwania na końcu ekranu znajduje się liczba wyszukanych plików i znalezione wiersze kodu.

Możesz użyć [^\n\s]\r\ndo pominięcia pustych i spacji wierszy (podziękowania dla Zacha w komentarzach).

Licznik linii open source dla VS2005, 2003 i 2002 jest dostępny tutaj:

http://www.wndtabs.com/

Omówiono także tworzenie dodatku VS do liczenia linii wraz z kodem w Codeproject

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

Również zręczne edytowanie gadżetów ma ładny licznik linii, tutaj:

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

a Microsoft Visual Studio Team System 2008 zawiera dobry licznik linii.

Pamiętaj tylko:

Mierzenie postępu programowania liniami kodu jest jak mierzenie postępu budowy samolotu według masy. Bill Gates

Oto aktualizacja programu Visual Studio 2012/2013/2015 dla tych, którzy chcą wykonać opcję „Znajdź” (która wydaje mi się najłatwiejsza): RegEx znajdzie wszystkie niepuste wiersze z kilkoma wykluczeniami, aby dać najdokładniejsze wyniki .

Wpisz następujący RegEx w polu „Znajdź”. Wybierz opcję „Użyj wyrażeń regularnych”. Zmień opcję wyszukiwania na „Bieżący projekt” lub „Całe rozwiązanie” w zależności od potrzeb. Teraz wybierz „Znajdź wszystko”. W dolnej części okna Znajdź wyniki zobaczysz „Pasujące linie”, czyli wiersze zliczania kodu.

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

Niniejszy RegEx wyklucza następujące elementy:

Komentarze

// This is a comment

Komentarze wielowierszowe (zakładając, że wiersze są poprawnie skomentowane z * przed każdą linią)

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

XML dla Intellisense

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

Komentarze HTML:

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

Za pomocą instrukcji:

using System;
using System.Web;

Otwieranie nawiasów klamrowych:

{

Zamykanie nawiasów klamrowych:

}

Uwaga: wszystko między nawiasami klamrowymi zostanie uwzględnione podczas wyszukiwania, ale w tym przykładzie liczą się tylko 4 wiersze kodu, zamiast 18 rzeczywistych niepustych wierszy:

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

Stworzyłem to, aby dać mi znacznie dokładniejszą liczbę LOC niż niektóre poprzednie opcje i pomyślałem, że podzielę się. Szefowie uwielbiają LOC, więc utknąłem z tym przez chwilę. Mam nadzieję, że ktoś inny uzna to za pomocne, daj mi znać, jeśli masz jakieś pytania lub potrzebujesz pomocy w jego uruchomieniu.

Znaleziono tę wskazówkę: LOC z VS Znajdź i zamień

Nie jest to wtyczka, jeśli tego właśnie szukasz.

cloc to doskonała linia poleceń, oparta na Perlu, wykonywalna dla systemu Windows, która rozbija puste wiersze, wiersze z komentarzem i wiersze kodu źródłowego, pogrupowane według formatów plików.

Teraz nie będzie specjalnie działał na pliku rozwiązania VS, ale może przeszukiwać katalogi, a Ty możesz ustawić filtry nazw plików według własnego uznania.

Oto przykładowe wyniki z ich strony internetowej:

prompt> cloc perl-5.10.0.tar.gz
    4076 plików tekstowych.
    3883 unikalne pliki.                                          
    1521 plików zignorowanych.

http://cloc.sourceforge.net v 1.07 T = 10.0 s (251,0 plików / s, 84566.5 linii / s)
-------------------------------------------------- -----------------------------
Pliki językowe pusty kod komentarza skala 3. gen. ekwiwalent
-------------------------------------------------- -----------------------------
Perl 2052 110356 112521 309778 x 4,00 = 1239112,00
C 135 18718 22862 140483 x 0,77 = 108171,91
Nagłówek C / C ++ 147 7650 12093 44042 x 1,00 = 44042.00
Powłoka Bourne'a 116 3402 5789 36882 x 3,81 = 140520,42
Lisp 1 684 2242 7515 x 1,25 = 9393,75
zrobić 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
Partia DOS 11 85 50 322 x 0,63 = 202,86
HTML 1 19 2 98 x 1,90 = 186,20
-------------------------------------------------- -----------------------------
SUMA: 2510 142085 156406 547174 x 2,84 = 1556285.03
-------------------------------------------------- -----------------------------

Skala ekwiwalentna trzeciej generacji to przybliżone oszacowanie, ile kodu zajmie język trzeciego pokolenia . Niezbyt przydatne, ale i tak interesujące.

Odpowiedzi tutaj są trochę nieaktualne, mogą pochodzić z czasu z 2008 roku. Ponieważ w nowszych wersjach programu Visual Studio 2010/2012 ta funkcja jest już wbudowana. Dlatego nie ma powodu, aby używać do tego jakiegokolwiek rozszerzenia lub narzędzi.

Funkcja zliczania linii kodu - Obliczanie danych. Za jego pomocą możesz obliczyć swoje wskaźniki (LOC, wskaźnik utrzymania, wskaźnik cyklomatyczny, głębokość dziedziczenia) dla każdego projektu lub rozwiązania.

Kliknij prawym przyciskiem myszy rozwiązanie lub projekt w Eksploratorze rozwiązań,

i wybierz „Oblicz dane”

Późniejsze dane do analizy i agregacji można zaimportować do programu Excel. Również w programie Excel możesz odfiltrować wygenerowane klasy lub inne szumy z danych. Dane te, w tym wiersze kodu LOC, można gromadzić także podczas procesu kompilacji i uwzględniać w raporcie kompilacji

Wyrażenia regularne zmieniły się między VS2010 a 2012, więc większość rozwiązań wyrażeń regularnych tutaj już nie działa

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

Znajdzie wszystkie wiersze, które nie są puste, nie są tylko pojedynczymi nawiasami („{” lub „}”), a nie tylko #include lub innym preprocesorem.

Użyj Ctrl- shift- fi upewnij się, że wyrażenia regularne są włączone.

Odpowiednie wyrażenie regularne dla VS 2010 i starszych to

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

W Visual Studio Team System 2008 możesz to zrobić z menu Analizuj -> „Oblicz metryki kodu dla rozwiązania”, a to da ci liczbę wierszy całego twojego rozwiązania (między innymi g )

Dla przyszłych czytelników chciałbym doradzić rozszerzenie DPack dla Visual Studio 2010 .

Ma wbudowane mnóstwo narzędzi, w tym licznik linii, który mówi, ile wierszy jest pustych, kodu itp.

Prostym rozwiązaniem jest wyszukiwanie we wszystkich plikach. Wpisz „*” podczas używania symboli wieloznacznych. Który pasowałby do wszystkich linii. Na końcu okna wyników wyszukiwania powinna pojawić się linia:

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

Oczywiście nie jest to bardzo dobre w przypadku dużych projektów, ponieważ wszystkie linie są macowane i ładowane do pamięci, aby wyświetlić je w oknie wyników wyszukiwania.

Odniesienie:

• Przykład zaawansowany

Możesz użyć:

• SCLOCCount http://www.dwheeler.com/sloccount/ - Otwarte źródło
• loc metrics, http://www.locmetrics.com/ - nie open source, ale łatwy w użyciu

Wolę OxyProject Metrics VS Addin.

Oczywiście narzędzia są łatwiejsze, ale czuję się świetnie, robiąc to w PowerShell :)

Ten skrypt znajduje wszystkie odniesienia .csproj w pliku .sln, a następnie w każdym pliku csproj lokalizuje pliki dołączone do kompilacji. Dla każdego pliku dołączonego do kompilacji tworzy obiekt o właściwościach: Rozwiązanie, Projekt, Plik, Linie. Przechowuje wszystkie te obiekty na liście, a następnie grupuje i wyświetla dane w razie potrzeby.

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

Inne proste narzędzie do VS2008 (open source): http://www.accendo.sk/Download/SourceStat.zip

Użyj Menu-> Analiza -> Oblicz metryki kodu w Visual Studio 2010 Ultimate.

Możesz użyć Visual Studio Code Metrics PowerTool 10.0 . Jest to narzędzie wiersza polecenia, które oblicza dla Ciebie kilka wskaźników kodu zarządzanego (w tym wierszy kodu). Możesz uzyskać wtyczkę VS 2010, która przenosi narzędzie do programu Visual Studio i sprawia, że ​​jest ono tak szybkie, jak wybranie pozycji menu i kliknięcie „Analizuj rozwiązanie”.

Zgadzam się z Ali Parr. Dodatek WndTab Line Counter jest takim narzędziem. http://www.codeproject.com/KB/macros/linecount.aspx

Dobrym pomysłem jest również wyszukiwanie z witryny pobierania w celu znalezienia powiązanego narzędzia. http://www.cnet.com/1770-5_1-0.html?query=code+counter&tag=srch

Oto sztuczka .. Liczy również plik Js.

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

Możesz użyć bezpłatnego narzędzia SourceMonitor

Daje wiele miar: linie kodu, liczba instrukcji, złożoność, głębokość bloku

Ma wyjścia graficzne za pomocą wykresów

Możesz użyć dodatku Project Line Counter w Visual Studio 2010. Zwykle nie działa z Visual Studio 2010, ale działa z pomocnym plikiem .reg tutaj: http://www.onemanmmo.com/index. php? cmd = newsitem & comment = news.1.41.0

Wymyśliłem szybki i brudny skrypt PowerShell do zliczania linii w strukturze folderów. Nie jest tak w pełni funkcjonalny, jak niektóre inne narzędzia wymienione w innych odpowiedziach, ale myślę, że jest wystarczająco dobry, aby zapewnić przybliżone porównanie wielkości plików kodu względem siebie w projekcie lub rozwiązaniu.

Skrypt można znaleźć tutaj:

https://gist.github.com/1674457

Wypróbuj neptuner. Oprócz LoC oferuje także takie rzeczy, jak spacje, tabulatory, linie komentarzy. http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip

W Visual Studio 2015 przejdź do menu Analiza i wybierz „Oblicz metryki kodu”.