How do you count the lines of code in a Visual Studio solution?

Question

Is it possible to find the number of lines of code in an entire solution? I've heard of MZ-Tools, but is there an open source equivalent?

I agree that it doesn't help much but if management are asking for it... — Fermin, Aug 07 '09 at 14:54
It's not neccesarily programming related, but it might give you an indication of the complexity of your code base. I was quite surprised to learn the size of our solution, using the PS script from Greg D. — Sune Rievers, Oct 01 '10 at 09:20
LoC is simply a metric and is particulairly interresting in 2 cases: 1) to get an idea how big the code base is i.e. when you join a new team 2) to measure your progress when trying to make your code base more compact — Piotr Owsiak, Oct 11 '10 at 17:07
Some people here are saying that counting lines of code is useless without giving it good thought. It is quite useful as it is a metric that should generally be minimized. It is a simple way to measure complexity of the solution(not efficiency) and if the problem is known to be simple, the more lines of code, generally the lower the quality. Another thing is why do people bother responding if it is just to say the question is a bad one? What would you think if a teacher told you your question just shouldn't be asked. — , May 14 '11 at 18:35
LoC is useful as long as you don't make too much of it. It's a decent indicator of the overall size and level of complexity of the application, but remember that it's easy to game line counts - anyone can find ways to pack lots of statements onto one line, or break a simple statement into lots of lines. Taking a look at it when you take over a new project is generally useful, but setting goals and measuring progress based on it is generally a bad idea. — Mason, Apr 13 '12 at 19:36
If you've spent months writing a WPF app, and your boss "just" wants you to change it to WinForms because somebody has been in his ear and said WPF was bad, you might want to "just" give him the faintest idea what he's asking. — SteveCav, Jul 17 '12 at 00:29
In VS2010 there is a in-built tool that counts all lines of code and other values too: Go to View -> Other Windows -> Code metrics results. A little button in the corner that looks like a calendar, click that, the tooltip should say Calculate code metrics for soulution, and let VS do it's thing. — user959631, Jul 27 '12 at 14:37
Sometimes a begineer programmer need some numbers to make himself feel like he accomplish something. — Joey Arnold Andres, Aug 09 '12 at 21:35
@KirillV.Lyadvinsky very useful as a component of estimating the cost to port a library from one language to another — FlavorScape, Nov 21 '12 at 22:10
The person doesn't always need to tell you why they want to count code. When the question is this simply stated, the case around why is irrelevant. Just answer his question. I hate that. There are times to ask why when clearly you need to and then there are times you don't (when you personally don't see a need...and are just badgering the poster in arrogance). — PositiveGuy, Jan 10 '13 at 22:26
The VS2010 (and even VS2012) built-in solution only seems to count LOC on the managed projects. If you are looking to count C++ lines you're outta luck. — wpfwannabe, Jul 23 '13 at 11:09
Go to View -> Other Windows -> Code Metrics Results You can export the result to Excel and filter by project / namespace etc. — Muhammedh, Dec 17 '13 at 08:19
As a programmer that has code reviewed for PCI requirements, this is an absolute necessity to know line counts. The cost goes up the mores lines of code you have. =) — Matty, Feb 08 '14 at 00:39
I believe code metrics in VS does not count lines of xml style source code files like XAML. — Shiv, Apr 21 '16 at 06:02
@Fermin I suggest you update the checkmarked answer. Herter's answer below (245 votes) is correct, as Visual Studio now includes this feature. — Evorlor, Feb 02 '17 at 16:13
Is there a way to count the lines of code on a day or something like this? — motevalizadeh, Jul 02 '17 at 12:13

Greg D · Answer 1 · 2016-10-06T16:42:39.067

964

I've found powershell useful for this. I consider LoC to be a pretty bogus metric anyway, so I don't believe anything more formal should be required.

From a smallish solution's directory:

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

That will count the non-blank lines in all the solution's .cs and .xaml files. For a larger project, I just used a different extension list:

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

Why use an entire app when a single command-line will do it? :)

edited Oct 06 '16 at 16:42

answered Aug 07 '09 at 14:02

Greg D

43,259
14
84
117

25

(The only time I've ever been asked to supply line counts was when upper management was figuring out how much time it would take to migrate all our products overseas so they could shut down our domestic site.) – Greg D Aug 07 '09 at 14:33
11

(Yes, this includes codegen'd files and comments. No, that doesn't bother me. Designers, gen'd code, and comments need to be maintained, too.) – Greg D Aug 10 '09 at 14:20
29

very nice, completely forgot about powershell. it should become default replacement for cmd – lubos hasko Jan 17 '10 at 14:40
5

Excellent! Your ending comment really sums it up, it's a trivial task, so why use a non-trivial tool? Though I really think it should be included in all versions of VS. – Sune Rievers Oct 01 '10 at 09:22
18

If you want to exclude the backing files generated for the XAML, you can just add an -exclude switch: `(dir -exclude *.g.cs -include *.cs,*.xaml -recurse | select-string .).Count` – E.Z. Hart Feb 04 '14 at 15:03
Beautiful. Keep in mind -exclude can be used to ignore files by name as well as extension; the command as given here on a relatively modest-sized application returned 1.8 million LoC, then I ignored a particular auto-generated file for a service proxy, as well as designer files for the UI, and got the much more realistic 118k lines of actual human-written code. – KeithS Aug 19 '14 at 15:56
2

Perfect, I prefer this to installing yet another plugin for VS or using an entire external program! – Alexandros Gouvatsos Sep 25 '15 at 14:34
1

Thats nice. Can I somehow exclude lines with fewer than a certain amount of characters, like { and } lines and such? Also I would like to exclude lines starting with "using" I think that could get closer to the amount of lines that where actually written by the programmer. – Ravior Dec 22 '16 at 23:16
1

@Ravior- You're missing the point. Lines of code is a terrible metric for anything meaningful the moment you start caring about minutiae like that. Tweaking the detailed rules around how it's calculated is effectively meaningless because it's fundamentally a relative (and mostly useless) measure. – Greg D Dec 27 '16 at 19:08
Nice!! since I am working on a big project, I wrote lots of small stand along programs, it's better to count what's in a folder instead of a solution – Benny Ae Feb 25 '19 at 23:21
what is the purpose of the period in "select-string ."? – user2628641 Mar 08 '19 at 01:59
It's a regex pattern, the `.` is a wildcard character. See select-string docs (https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/select-string?view=powershell-6) and powershell regex docs (https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_regular_expressions?view=powershell-6) – Greg D May 15 '19 at 20:42
1

this should be more efficient: `dir -Recurse -Include *.ts,*.tsx -Exclude *node_modules* | Get-Content | Measure-Object -Line` [How to count all the lines of code in a directory recursively on Windows?](https://superuser.com/a/1454083/241386) – phuclv Feb 20 '20 at 06:47
For the WSL users try `grep -Pr --include=*.{cs,xaml} '[\S]' * | wc -l` – Moir Jul 08 '22 at 18:59

score 723 · Accepted Answer · edited Aug 09 '21 at 21:42

723

Visual Studio has built-in code metrics, including lines of code:

Analyze → Calculate Code Metrics

edited Aug 09 '21 at 21:42

adamj537

677
7
14

answered Mar 01 '11 at 02:25

Linora

10,418
9
38
49

14

Ultimate and Premium, I think – Stefan Dragnev Aug 29 '11 at 16:42
Premium does include it. However, it seems to skip over code files where the type is defined in xaml. – Trevor Tubbs Mar 22 '12 at 15:19
52

Warning: This does many other things besides simply line count. It also lists "Maintainability Index", "Cyclomatic Complexity", "Depth of Inheritance", and "Class Coupling", all of which are pretty complicated to compute, and you can't run the metrics for just part of it. What this means is that if your code-base is particularly large, you might be sitting for hours waiting for it. If all you want is line-count, there's much faster solutions out there. – Darrel Hoffman Sep 24 '12 at 17:55
@Darrel Hoffman - that is of course very true.. You should use a more lightweight option if you want the LOC on a huge project – Linora Sep 26 '12 at 12:22
Lines of code that this calculates (in VS2010) are approximation of the lines of executable code. – VoodooChild Jan 14 '13 at 16:48
4

also on vs2012 ultimate =) – oCcSking May 21 '13 at 10:35
@Darrel Hoffman it's not calculating number of lines, but pure code lines (empty lines, parentheses, comments, and usings are not calculated here) – Hamzeh Soboh May 06 '14 at 06:35
@HamzehSoboh Sure, but it'll still take forever calculating all that other stuff if your codebase is of any significant size. I was working on a project with LOC in billions (not exaggerating) when I posted that. This tool was essentially useless for that, unless you wanted to just let it run overnight... – Darrel Hoffman May 10 '14 at 20:36
56

Too bad this doesn't work with native C++ projects (at least it doesn't in VS2013). – Cameron Sep 18 '14 at 18:22
1

I need to count lines for several projects that still do not compile, and this requires the code is currently compiling, so this is not a valid option in use cases like mine. – Allan.C Apr 28 '15 at 22:52
1

Yeah I agree it isnt perfect, but in most cases it will suffice – Linora Oct 06 '15 at 12:16
Down-voted because after 20 minutes i can only see Loc _per project_ and not for the entire solution. The results cant even be copy pasted to Excel. – David May 22 '16 at 21:56
3

@David there's a dedicated button to export the data to Excel, right above the results. – Crono Aug 25 '16 at 20:32
2

It should be mentioned that this solution will exclude any code that's marked with `GeneratedCodeAttribute`. Meaning any code that's generated by a designer, a tool, etc. – Crono Aug 25 '16 at 20:36
@VSG24, where exactly, could you please elaborate? – sunny moon Aug 30 '16 at 11:56
@sunnymoon Same place. Top menu -> Analyze -> Run Code Analysis -> On Solution. You can access the same functionality from View -> Other Windows -> Code Metrics Results – Eternal21 Sep 02 '16 at 15:07
6

It's worth noting that according to [msdn](https://msdn.microsoft.com/en-us/library/bb385914.aspx) the amount of LoC calculated is based on **IL**, not the *actual code*. – GGG Nov 03 '16 at 04:26
4

This might be useful for pure .NET code, but for example, in a web application where you have JavaScript, HTML, CSS, and possibly other code beyond .NET, this is unhelpful. I ran this against my Angular application that is 100% JavaScript/HTML/CSS and was informed it contains 0 lines of code. – dmeglio Feb 28 '17 at 21:14
Works fine with Visual Studio 2017 Enterprise – Oswald Jun 16 '17 at 12:48
revisiting this thread i used this tool but it doesn't work like you'd expect i counted the lines by myself i got about 1100 but this tool just showed about 600 lines. I'm guessing they only measure function code and not structural code. All my delegates totalled 0 lines of code. – CyberFox Jan 09 '18 at 04:53
7

[According to MSDN](https://msdn.microsoft.com/en-us/library/bb385914.aspx), this count is based on the IL and therefore not reflective of the number of lines of source code. @CyberFox – Sinjai Aug 28 '18 at 06:02
That is not exact as it doesn't count your lines of code. Instead, you'll get the count of the IL compiled lines. – Davide Cannizzo Oct 05 '18 at 17:32
Lines of Code - Indicates the approximate number of lines in the code. The count is based on the IL code and is therefore not the exact number of lines in the source code file. A very high count might indicate that a type or method is trying to do too much work and should be split up. It might also indicate that the type or method might be hard to maintain. – Suhas Dhongade Jan 11 '19 at 14:41
Does this count empty lines? – FernandoG Nov 27 '19 at 16:05
@FernandoG yes. they fixed the documentation concerning this recently. https://learn.microsoft.com/de-de/visualstudio/code-quality/code-metrics-values?view=vs-2019&redirectedfrom=MSDN – Welcor Jan 29 '20 at 15:56
Still works in VS2019...BUT..."only for VB and C# projects that are not web or shared projects" (you get a warning if there are any such). If you are in any other project type then the option - in the main menu Analyze or in the context ment - is not even available! – AndrewD Jul 01 '20 at 10:14
This method is deprecated, not supported in 2019 – Nagy Szabolcs Dec 09 '20 at 11:45
This worked in VS2019 for ASP.NET 5 project BUT it completely ignored all the razor `.cshtml` files, `.js`, `.css` and other "non C#" stuff. Use the powershell answer – Alex from Jitbit Sep 18 '21 at 06:54

score 388 · Answer 3 · edited May 16 '20 at 15:25

388

I used Ctrl+Shift+F. Next, put a \n in the search box and enable regular expressions box. Then in the find results, in the end of the screen are the number of files searched and lines of code found.

You can use [^\n\s]\r\n to skip blank and space-only lines (credits to Zach in the comments).

edited May 16 '20 at 15:25

Abel

56,041
24
146
247

answered Feb 21 '12 at 20:46

NicolasKittsteiner

4,280
1
20
17

19

This solution incorrectly includes blank lines, comments, documentation, and split statements. For many applications, those should not count as lines of code. – Jay Baxter Mar 26 '14 at 22:32
2

Although it is slightly inaccurate (if you actually use \n in your code, that line will be double counted), it is still the best answer if you need a ROM of lines of code without a 3rd party tool – Joseph Duty Aug 20 '15 at 13:32
1

You can also select a specific file type by selecting an option `Look at these file types:` dropdown just bellow the `enable regular expressions box` . – Moshi Oct 24 '15 at 18:35
You can disable regular expressions to know actual usage of "\n" – Naresh Mar 02 '16 at 02:38
2

Works for very small projects... when you have a 100 million lines of code this will take some time. – marsh May 16 '16 at 18:18
1

Works great! I wanted to know how many lines of code I've programmed in the last week. 15,000 lines. That's prettty cool :D – Kevin Jensen Petersen May 20 '16 at 13:35
1

Perfect solution. To be more accurate, "Look for these files" `*.cs; *.aspx,*.sql, *.css, *.skin, *.master,*.xsd,*.txt,*.ascx,*.config,*.sitemap`. This will give accurate line counts in ASP.NET Web Application. – TheTechGuy Sep 28 '16 at 05:17
I like this answer because it can include JS, HTML, CSS, etc, which ended up making a huge difference (like 25 times higher) – David Starkey Dec 27 '17 at 16:36
21

`[^\n\s]\r\n` skips blank lines, even with spaces in them. – Zach Mierzejewski Apr 17 '18 at 16:26
I used the two methods. The line count with [^\n\s]\r\n to skip blank lines gives me 45,000 lines and the menu > Analyze > Calculate Code Metrics > For Solution method shows me 15,000 lines of source code. So.. this for me is about a 3:1 ratio. So use the line count, divide by 3 and you get a good estimate. – Mario Levesque Mar 05 '20 at 22:07
@ZachMierzejewski 's solution does not count lines of code that end with a space character before new line – Daniel Gabado Apr 26 '21 at 19:43
For my solution it counted almost 500,000 lines in a couple of seconds, very nice. – StayOnTarget Jun 22 '23 at 15:29

score 221 · Answer 4 · edited Jul 28 '15 at 07:45

221

An open source line counter for VS2005, 2003 and 2002 is available here:

http://www.wndtabs.com/

There is also discussion of creating a line counting VS addin, complete with code on Codeproject, here

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

Also Slick Edit Gadgets have a nice line-counter, here:

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

and Microsoft Visual Studio Team System 2008 includes a good line counter.

Just remember though:

Measuring programming progress by lines of code is like measuring aircraft building progress by weight. Bill Gates

edited Jul 28 '15 at 07:45

MWS

78
3
10

answered Aug 07 '09 at 13:43

Ali Parr

4,737
3
31
35

1

Often counting lines of code is Just Plain Silly, and quantity does not imply quality. However, a huge team putting a 545,000 lb (545,000 lb!!) Dreamliner in the air is an entirely different accomplishment than launching the ultralite I built single handedly in my garage. And if you think about the number of lines of code in Windows, maybe Mr. Bill meant this in a different way than it is usually taken...? – MickeyfAgain_BeforeExitOfSO May 13 '10 at 14:31
18

**None of these seem to apply to Visual Studio 2010, and the slickedit link is broken.** – MGOwen Jun 29 '11 at 01:42
57

You find the LOC feature in Visual Studio 2010 Ultimate under *"Analysis > Code metrics"* I hope I translated it right. I have the German version. There it is "Analyse" > "Codemetriken berechnen" – OneWorld Mar 16 '12 at 19:08
1

Lines of code can be somewhat useful if you want to do a comparison of #Bugs/LOC. Not that this metric should be used to hire/fire people but as a personal goal to reduce that number, actually reduce both LOC to achieve same output and bugs/LOC – Dave Jellison Jun 27 '12 at 15:10
1

@OneWorld Only in Premium and above. Professional doesn't have it. – Polynomial Sep 19 '12 at 13:10
1

@Polynomial You are right. So, we can say, you need either Premium or Ultimate. Also see the [wikipedia article](http://en.wikipedia.org/wiki/Microsoft_Visual_Studio#Editions) under the headlines "Editions feature grid" and "Visual Studio Ultimate 2010" – OneWorld Oct 08 '12 at 13:08
1

I agree with the quote of BG but LOC are a great indicator of how much is going to cost to maintain a software project, maybe that quote is a reason of how MS understimate this indicator. – NicolasKittsteiner Dec 05 '13 at 19:41
2

for Visual Studio 2012 the LoC metric could be find at _ANALYZE > Calculate Code Metrics for Solution_ – tetri Dec 17 '13 at 17:08
2

Also, VS2012 includes this feature in both the Ultimate and Premium editions (and now Professional as well). – SWalters Dec 17 '13 at 17:09
@Ali parr nice quote , straight way to convince the client – Kandarp Vyas Jul 23 '14 at 18:49
I measure my progress, in part by counting lines, but those I remove indicate progress, not those I add. – ProfK Sep 01 '14 at 07:28
Love the quote from Bill Gates. The last person I would ask for programming tips. Actually it's nothing like it at all but just like any other metric it only gives one small piece of the puzzle. If you have 300 user stories to write and the dev mgr says they have written 500 lines of code then you can get a feel that progress is not going well. – ComeIn Jan 15 '17 at 07:45

Howard Renollet · Answer 5 · 2016-09-08T12:38:56.820

Here's an update for Visual Studio 2012/2013/2015 for those who want to do the "Find" option (which I find to be the easiest): This RegEx will find all non-blank lines with several exclusions to give the most accurate results.

Enter the following RegEx into the "Find" box. Please make sure to select the "Use Regular Expressions" option. Change the search option to either "Current Project" or "Entire Solution" depending on your needs. Now select "Find All". At the bottom of the Find Results window, you will see "Matching Lines" which is the lines of code count.

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

This RegEx excludes the following items:

Comments

// This is a comment

Multi-Line comments (assuming the lines are correctly commented with a * in front of each line)

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

XML for Intellisense

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

HTML Comments:

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

Using statements:

using System;
using System.Web;

Opening curly braces:

Closing curly braces:

Note: anything between the braces would be included in the search, but in this example only 4 lines of code would count, instead of 18 actual non-blank lines:

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

I created this to give me a much more accurate LOC count than some previous options, and figured I would share. The bosses love LOC counts, so I'm stuck with it for a while. I hope someone else can find this helpful, let me know if you have any questions or need help getting it to work.

Love the downvote without comment. This shouldn't be allowed. What about my solution doesn't work??? I don't even care about the votes, I just wanted to post an update for VS2012-2013 users. — Howard Renollet, Feb 20 '14 at 13:33
Hard to filter out all generated code (AssemblyInfo etc.) so Analyze/Calculate Code Metrics should be preferred. — MKesper, Jan 22 '16 at 09:56
Great job, but please mention about the **Use Regular Expression** checkbox under the **Find Options** section. It makes it much easier — Gogutz, Apr 16 '16 at 18:40
A simpler version if no XML, nor HTML... ^(?([^\r\n])\s)*[^\s+?/]+[^\n]*$. — LastBlow, Jun 07 '18 at 16:53
With the "Use Regular Expression" copy/pasting this regex expression produced an error message highlighted in red for me. Any ideas of what i'm doing wrong ? The message was **"Invalid regular expression".** — Jeanclaude, Feb 01 '21 at 05:32

score 81 · Answer 6 · answered Feb 28 '10 at 14:27

81

Found this tip: LOC with VS Find and replace

Not a plugin though if thats what you are looking for.

answered Feb 28 '10 at 14:27

Mads Andersen

3,123
5
38
44

I love this one, but I think I found a small error in the expression there. For VB.Net I think it should be ^~(:Wh@')~(:Wh@\#).+ and for C# I think ^~(:Wh@//)~(:Wh@\{:Wh@)~(:Wh@\}:Wh@)~(:Wh@\#).+ That way blank comment lines and compiler directives are properly dealt with. It worked better for me with VB.NET anyway, and C# I haven't tested. – user12861 Aug 03 '11 at 14:33
^~(:Wh@//)~(:Wh@\{:Wh@)~(:Wh@\}:Wh@)~(:Wh@\#)~(:Wh@$).+ ended up working better for C#, I was getting some lines consisting of just whitespace. – user12861 Aug 05 '11 at 14:23
Does n't it count all commented lines also? Just lines of CODE please! – HydPhani Apr 15 '13 at 07:44
4

Here's one that I crated with that works in VS2012 (the one posted is outdated as of 2010) and only counts lines of code. It excludes all comments, using directives, curly braces, xml directives, blank lines, etc.... to give you a true code only count: ^(?!(\s*\*))(?!(\s*\-\-\>))(?!(\s*\<\!\-\-))(?!(\s*\n))(?!(\s*\*\/))(?!(\s*\/\*))(?!(\s*\/\/\/))(?!(\s*\/\/))(?!(\s*\}))(?!(\s*\{))(?!(\s(using))).*$ – Howard Renollet Nov 04 '13 at 17:43

score 72 · Answer 7 · edited Jul 29 '16 at 12:52

cloc is an excellent commandline, Perl-based, Windows-executable which will break down the blank lines, commented lines, and source lines of code, grouped by file-formats.

Now it won't specifically run on a VS solution file, but it can recurse through directories, and you can set up filename filters as you see fit.

Here's the sample output from their web page:


prompt> cloc perl-5.10.0.tar.gz
    4076 text files.
    3883 unique files.                                          
    1521 files ignored.

http://cloc.sourceforge.net v 1.07  T=10.0 s (251.0 files/s, 84566.5 lines/s)
-------------------------------------------------------------------------------
Language          files     blank   comment      code    scale   3rd gen. equiv
-------------------------------------------------------------------------------
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
make                  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 Batch            11        85        50       322 x   0.63 =         202.86
HTML                  1        19         2        98 x   1.90 =         186.20
-------------------------------------------------------------------------------
SUM:               2510    142085    156406    547174 x   2.84 =     1556285.03
-------------------------------------------------------------------------------

The third generation equivalent scale is a rough estimate of how much code it would take in a third generation language. Not terribly useful, but interesting anyway.

This is great and super easy to use. Much easier than the Find/Replace solutions and more clear what it's actually doing than the VS Code Metrics option. Just `choco install cloc` and then `cloc .` in your solution dir. Job done! — Rory, Jul 29 '16 at 12:50
I downloaded the Windows EXE from the [CLOC website](https://github.com/AlDanial/cloc) and ran it in my Visual Studio 2017 website project folder. Worked like a charm. I like the --by-file-by-lang option that lists line count per individual file and language, sorted from largest to smallest. — humbads, Mar 29 '18 at 18:25

Regfor · Answer 8 · 2012-11-14T18:02:07.173

44

Answers here are a little bit out of date, may be from vs 2008 time. Because in newer Visual Studio versions 2010/2012, this feature is already built-in. Thus there are no reason to use any extension or tools for it.

Feature to count lines of code - Calculate Metrics. With it you can calculate your metrics (LOC, Maintaince index, Cyclomatic index, Depth of inheritence) for each project or solution.

Just right click on solution or project in Solution Explorer,

enter image description here

and select "Calculate metrics"

enter image description here

Later data for analysis and aggregation could be imported to Excel. Also in Excel you can filter out generated classes, or other noise from your metrics. These metrics including Lines of code LOC could be gathered also during build process, and included in build report

edited Nov 14 '12 at 18:02

answered Nov 14 '12 at 10:45

Regfor

8,515
1
38
51

2

Visual Studio 2010 also have this metrics. Actually nothing new in VS2012 at all. – Mike Chaliy Nov 14 '12 at 11:03
1

Yep, but answers here are from time of vs 2008 and a little bit out of date, why use anything or install some extension when it's a built-in feature. And even it's not new feature many people do not know about it. – Regfor Nov 14 '12 at 11:42
@MikeChaliy May be second introduction sentence has confused you, so I've rewritten it a little bit to avoid such confusion. – Regfor Nov 14 '12 at 11:49
i have a n-layer solution but that display this error: "Exception has been thrown by the target of an invocation." why? – user197508 Nov 16 '12 at 18:38
@Regfor I disagree with your statement, "no reason to use any extension or tools for it.". If I, as I do, wish to count the lines of code in 500 solution files why would I want to open them individually in VS to view the lines of code. A stand alone tool would be much more efficient. – Michael Eakins Feb 20 '13 at 19:49
@MichaelEakins Everyone decides for himself, based on concrete situation. I just want to say that that such task could be accomplished without any 3rd party tools. But there are many ways how to achieve it: implement something (script or tool), buy something or use something(e.g. NDepend for more then 500$ or install Sonar) etc. So maybe we should think about it in scope of other more concrete question – Regfor Feb 21 '13 at 08:32
6

This is not lines of code, but Compiled Lines (ie after it is turned into IL). I think Fermin was looking for pre compiled lines. – mikeschuld Apr 19 '13 at 01:48
If I understand correctly, this will miss XAML, XML, RESX etc. – Shiv Aug 05 '14 at 05:59
1

I just found out that this tool won't work for C++. It can only analyze managed code. – ferchor2003 May 05 '21 at 17:02

score 29 · Answer 9 · edited Jun 17 '15 at 10:24

Regular expressions have changed between VS2010 and 2012, so most of the regular expression solutions here no longer work

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

Will find all lines that are not blank, are not just a single bracket ( '{' or '}' ) and not just a #include or other preprocessor.

Use Ctrl-shift-f and make sure regular expressions are enabled.

The corresponding regular expression for VS 2010 and older is

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

score 19 · Answer 10 · answered Aug 07 '09 at 13:51

19

In Visual Studio Team System 2008 you can do from the menu Analyze--> 'Calculate Code Metrics for Solution' and it will give you a line count of your entire solution (among other things g)

answered Aug 07 '09 at 13:51

Christopher Klein

2,773
4
39
61

12

Visual Studio Team System 2008 doesn't manage to count unmanaged code. ;) – Christian Feb 03 '10 at 14:29
This doesn't work with c++ (even in VS 2022). – Steve A Nov 30 '22 at 16:00

score 17 · Answer 11 · edited Jun 17 '15 at 10:07

17

For future readers I'd like to advise the DPack extension for Visual Studio 2010.

It's got a load of utilities built in including a line counter which says how many lines are blank, code, and etc.

edited Jun 17 '15 at 10:07

Philipp M

1,877
7
27
38

answered Mar 17 '12 at 17:03

Ashley Davies

1,873
1
23
42

There is also a [version for VS 2012](https://visualstudiogallery.msdn.microsoft.com/93d77d1c-5a31-4b3d-9dbc-6e4efaa4bf1c) – Philipp M Jun 17 '15 at 11:03

score 14 · Answer 12 · edited Jun 20 '11 at 01:40

A simple solution is to search in all files. Type in "*" while using wildcards. Which would match all lines. At the end of the find results window you should see a line of the sort:

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

Of course this is not very good for large projects, since all lines are mached and loaded into memory to be dispayed at the find results window.

Reference:

Advanced Example

score 13 · Answer 13 · answered Jul 31 '20 at 13:51

13

In Visual Studio 2019, from the top menu you need to select:

'Analyze' -> 'Calculate Code Metrics' -> 'For Solution'

This works in both Visual Studio 2019 Professional and Enterprise.

answered Jul 31 '20 at 13:51

Adrian Thompson Phillips

6,893
6
38
69

2

Not applicable for C/C++ project. Only available for C# and Visual Basic that they are not website projects or shared projects – Mohamed Hamzaoui Jul 06 '21 at 16:00
1

Also available or Visual Studio 2019/2022 Community – Nick Pearce Oct 21 '21 at 21:09

score 11 · Answer 14 · answered Aug 07 '09 at 13:39

11

You could use:

SCLOCCount http://www.dwheeler.com/sloccount/- Open source
loc metrics, http://www.locmetrics.com/ - not open source, but easy to use

answered Aug 07 '09 at 13:39

Edward Wilde

25,967
8
55
64

score 6 · Answer 15 · answered May 13 '10 at 14:00

6

I prefer OxyProject Metrics VS Addin.

answered May 13 '10 at 14:00

Selçuk Öztürk

975
1
14
23

score 4 · Answer 16 · answered May 22 '13 at 09:05

Obviously tools are easier, but I feel cool doing this in powershell:)

This script finds all the .csproj references in the .sln file, and then within each csproj file it locates files included for compilation. For each file that is included for compilation it creates an object with properties: Solution, Project, File, Lines. It stores all these objects in a list, and then groups and projects the data as needed.

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

score 4 · Answer 17 · answered Jan 17 '10 at 14:34

4

Other simple tool For VS2008 (open source): http://www.accendo.sk/Download/SourceStat.zip

answered Jan 17 '10 at 14:34

LiborBes

81
1

score 3 · Answer 18 · answered Apr 15 '14 at 18:55

You can use the Visual Studio Code Metrics PowerTool 10.0. It's a command-line utility that calculates a few metrics on managed code for you (including lines of code). You can get a VS 2010 plugin that brings the tool into Visual Studio, and makes it as quick as selecting the menu item and clicking "Analyze Solution."

score 3 · Answer 19 · answered Jul 11 '11 at 22:14

3

Use Menu-> Analyse - > Calculate Code Metrics option in Visual Studio 2010 Ultimate.

answered Jul 11 '11 at 22:14

sunil

39
1

score 2 · Answer 20 · answered May 22 '13 at 09:49

2

Here is the Trick.. It counts the Js file also.

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

answered May 22 '13 at 09:49

Anish Karunakaran

987
3
17
39

score 2 · Answer 21 · answered Apr 08 '14 at 07:16

2

You can use free tool SourceMonitor

Gives a lot of measures: Lines of Code, Statement Count, Complexity, Block Depth

Has graphical outputs via charts

answered Apr 08 '14 at 07:16

Hovhannes Hakobyan

1,266
12
14

score 2 · Answer 22 · answered Mar 11 '12 at 01:21

Agree with Ali Parr. The WndTab Line Counter addin is a such tool. http://www.codeproject.com/KB/macros/linecount.aspx

It's also a good idea to search from download site to find some related tool. http://www.cnet.com/1770-5_1-0.html?query=code+counter&tag=srch

score 1 · Answer 23 · answered May 13 '10 at 14:07

1

Try neptuner. It also gives you stuff like spaces, tabs, Lines of comments in addition to LoC. http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip

answered May 13 '10 at 14:07

sonofdelphi

1,986
5
19
25

score 1 · Answer 24 · answered Jan 28 '17 at 22:45

1

In Visual Studio 2015 go to the Analyze Menu and select "Calculate Code Metrics".

answered Jan 28 '17 at 22:45

Atters

801
8
19

1

This doesn't work for c++ projects (still, as of 2022). – Steve A Nov 30 '22 at 15:57

score 1 · Answer 25 · answered Jun 04 '11 at 07:44

1

You can use the Project Line Counter add-in in Visual Studio 2010. Normally it doesn't work with Visual Studio 2010, but it does with a helpful .reg file from here: http://www.onemanmmo.com/index.php?cmd=newsitem&comment=news.1.41.0

answered Jun 04 '11 at 07:44

Robert Basler

371
2
9

score 1 · Answer 26 · answered Jan 25 '12 at 03:18

I came up with a quick and dirty powershell script for counting lines in a folder structure. It's not nearly as full featured as some of the other tools referenced in other answers, but I think it's good enough to provide a rough comparison of the size of code files relative to one another in a project or solution.

The script can be found here:

https://gist.github.com/1674457

How do you count the lines of code in a Visual Studio solution?

26 Answers26

Linked

Related