Como você conta as linhas de código em uma solução do Visual Studio?

800

É possível encontrar o número de linhas de código em uma solução inteira? Eu ouvi falar do MZ-Tools , mas existe um equivalente de código aberto?

Fermin
fonte
24
Eu concordo que isso não ajuda muito, mas se a gestão está pedindo para ele ...
Fermin
33
LoC é simplesmente uma métrica e é particularmente interessante em 2 casos: 1) para ter uma idéia do tamanho da base de código, ou seja, quando você ingressa em uma nova equipe 2) para medir seu progresso ao tentar tornar sua base de código mais compacta
Piotr Owsiak
191
Algumas pessoas aqui estão dizendo que contar linhas de código é inútil sem pensar bem. É bastante útil, pois é uma métrica que geralmente deve ser minimizada. É uma maneira simples de medir a complexidade da solução (não a eficiência) e, se se sabe que o problema é simples, quanto mais linhas de código, geralmente menor a qualidade. Outra coisa é por que as pessoas se incomodam em responder se é apenas para dizer que a pergunta é ruim? O que você pensaria se um professor lhe dissesse sua pergunta simplesmente não deveria ser feita.
77
No VS2010, há uma ferramenta integrada que conta todas as linhas de código e outros valores: Vá para Exibir -> Outras janelas -> Resultados das métricas de código. Um pequeno botão no canto que se parece com um calendário, clique nele, a dica de ferramenta deve dizer Calcular métricas de código para execução da alma e deixar o VS fazer isso.
user959631
64
A pessoa nem sempre precisa lhe dizer por que deseja contar o código. Quando a questão é simplesmente afirmada, o caso em torno do motivo é irrelevante. Apenas responda a sua pergunta. Eu odeio isso. Há momentos em que perguntamos por que razão quando claramente você precisa e há momentos em que você não vê (quando você pessoalmente não vê uma necessidade ... e está apenas atormentando o cartaz com arrogância).
PositiveGuy

Respostas:

525

O Visual Studio 2010 Ultimate possui este built-in:

Analisar → Calcular métricas de código

Herter
fonte
12
Ultimate e Premium, eu acho #
Stefan Dragnev
39
Aviso: Isso faz muitas outras coisas além da simples contagem de linhas. Ele também lista o "Índice de Manutenção", "Complexidade Ciclomática", "Profundidade da Herança" e "Acoplamento de Classes", que são bastante complicados de calcular, e você não pode executar as métricas para apenas parte dele. O que isso significa é que, se sua base de código for particularmente grande, você poderá ficar horas esperando por ela. Se tudo o que você deseja é contagem de linhas, existem soluções muito mais rápidas por aí.
Darrel Hoffman
4
também em vs2012 ultimate =) #
0190 oCcSking
9
O VS 2013 tem Analyze -> Calcular métricas de código
Dinesh Rajan
42
Pena que isso não funciona com projetos C ++ nativos (pelo menos não no VS2013).
Cameron
844

Eu achei o PowerShell útil para isso. Eu considero LoC uma métrica bastante falsa de qualquer maneira, então não acredito que algo mais formal deva ser necessário.

Do diretório de uma solução pequena:

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

Isso contará as linhas não em branco em todos os arquivos .cs e .xaml da solução. Para um projeto maior, usei apenas uma lista de extensões diferente:

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

Por que usar um aplicativo inteiro quando uma única linha de comando o faz? :)

Greg D
fonte
19
(A única vez que eu fui perguntado sempre a contagem de linha de abastecimento foi quando a alta gerência foi descobrir quanto tempo levaria para migrar todos os nossos produtos no exterior para que eles pudessem encerrar nosso site doméstica.)
Greg D
8
(Sim, isso inclui arquivos codegen'd e comentários Não, isso não me incomoda Designers, código gen'd e comentários precisam ser mantidos também...)
Greg D
27
muito legal, esqueci completamente o PowerShell. ele deve tornar-se a substituição padrão para cmd
Lubos Hasko
4
Excelente! Seu comentário final realmente resume tudo, é uma tarefa trivial, então por que usar uma ferramenta não trivial? Embora eu realmente ache que deve ser incluído em todas as versões do VS.
Sune Rievers 01/10/10
13
Se você deseja excluir os arquivos de backup gerados para o XAML, basta adicionar uma opção -exclude: (dir -exclude *.g.cs -include *.cs,*.xaml -recurse | select-string .).Count
EZ Hart
349

Eu usei Ctrl+ Shift+ F. Em seguida, coloque um \nna caixa de pesquisa e ative a caixa de expressões regulares. Então, nos resultados da busca, no final da tela estão o número de arquivos pesquisados ​​e as linhas de código encontradas.

Você pode usar [^\n\s]\r\npara pular linhas em branco e somente espaço (créditos para Zach nos comentários).

NicolásKittsteiner
fonte
16
Esta solução incorretamente inclui linhas em branco, comentários, documentação e instruções de divisão. Para muitos aplicativos, esses não devem contar como linhas de código.
Jay Baxter
1
Embora seja um pouco impreciso (se você realmente usar \ n no seu código, essa linha será contada duas vezes), ainda é a melhor resposta se você precisar de uma ROM de linhas de código sem uma ferramenta de terceiros
Joseph Duty
1
Você também pode selecionar um tipo de arquivo específico, selecionando um Look at these file types:menu suspenso abaixo enable regular expressions box.
Moshii 24/10/2015
1
Funciona para projetos muito pequenos ... quando você tiver 100 milhões de linhas de código, isso levará algum tempo.
Marsh #
11
[^\n\s]\r\npula linhas em branco, mesmo com espaços.
Zach Mierzejewski
219

Um contador de linha de código aberto para VS2005, 2003 e 2002 está disponível aqui:

http://www.wndtabs.com/

Também se discute a criação de uma linha de contagem de suplemento VS, completa com o código no Codeproject, aqui

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

Os Slick Edit Gadgets também têm um bom contador de linhas, aqui:

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

e o Microsoft Visual Studio Team System 2008 inclui um bom contador de linhas.

Apenas lembre-se:

Medir o progresso da programação por linhas de código é como medir o progresso da construção de aeronaves em peso. Bill Gates

Ali Parr
fonte
1
Muitas vezes, contar linhas de código é simplesmente tolo e quantidade não implica qualidade. No entanto, uma equipe enorme colocando um Dreamliner de 545.000 lb (545.000 lb !!) é uma conquista totalmente diferente do que o lançamento do ultralite que construí sozinho na minha garagem. E se você pensar no número de linhas de código no Windows, talvez o Sr. Bill tenha entendido isso de uma maneira diferente da que geralmente é usada ...?
UnconditionallyReinstateMonica
18
Nada disso parece se aplicar ao Visual Studio 2010, e o link slickedit está quebrado.
MGOwen
57
Você encontra o recurso LOC no Visual Studio 2010 Ultimate em "Análise> Métricas de código" . Espero ter traduzido corretamente. Eu tenho a versão alemã. Aí está "Analyze"> "Codemetriken berechnen"
OneWorld
2
para o Visual Studio 2012, a métrica LoC pode ser encontrada em ANALYZE> Calcular métricas de código para solução
tetri
2
Além disso, o VS2012 inclui esse recurso nas edições Ultimate e Premium (e agora também no Professional).
SWalters - Restabelece Monica
81

Aqui está uma atualização para o Visual Studio 2012/2013/2015 para quem deseja fazer a opção "Localizar" (que eu acho mais fácil): Este RegEx encontrará todas as linhas não em branco com várias exclusões para fornecer os resultados mais precisos .

Digite o seguinte RegEx na caixa "Localizar". Certifique-se de selecionar a opção "Usar expressões regulares". Altere a opção de pesquisa para "Projeto atual" ou "Solução inteira", dependendo de suas necessidades. Agora selecione "Find All". Na parte inferior da janela Resultados da pesquisa , você verá "Linhas correspondentes", que são as linhas da contagem de códigos.


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

Este RegEx exclui os seguintes itens:


Comentários

// This is a comment

Comentários de várias linhas (supondo que as linhas sejam comentadas corretamente com um * na frente de cada linha)

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

XML para Intellisense

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

Comentários em HTML:

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

Usando instruções:

using System;
using System.Web;

Abertura de chaves:

{

Fechamento de chaves:

}

Nota: qualquer coisa entre os colchetes seria incluída na pesquisa, mas neste exemplo, apenas 4 linhas de código serão contadas, em vez de 18 linhas não em branco reais:

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

Eu criei isso para me fornecer uma contagem LOC muito mais precisa do que algumas opções anteriores e achei que eu compartilharia. Os chefes adoram a contagem do LOC, por isso fico preso por um tempo. Espero que outra pessoa possa achar isso útil, deixe-me saber se você tiver alguma dúvida ou precisar de ajuda para fazê-lo funcionar.

Howard Renollet
fonte
18
Ame o voto negativo sem comentar. Isso não deve ser permitido. E a minha solução não funciona ??? Eu nem me importo com os votos, só queria postar uma atualização para os usuários do VS2012-2013.
Howard Renollet
Difícil filtrar todo o código gerado (AssemblyInfo etc.), portanto, Analisar / Calcular Métricas de Código deve ser o preferido.
MKesper
4
Ótimo trabalho, mas mencione a caixa de seleção Usar expressão regular na seção Opções de localização . Isso torna muito mais fácil
Gogutz
@MKesper Mas isso não funciona para C ++
d7samurai
Uma versão mais simples, se não houver XML, nem HTML ... ^ (? ([^ \ R \ n]) \ s) * [^ \ s +? /] + [^ \ N] * $.
LastBlow
80

Encontrou esta dica: LOC with VS Localizar e substituir

Não é um plugin, se é isso que você está procurando.

Mads Andersen
fonte
Eu amo esse, mas acho que encontrei um pequeno erro na expressão lá. Para o VB.Net, acho que deveria ser ^ ~ (: Wh @ ') ~ (: Wh @ \ #). + E para C # acho que ^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #). + Dessa forma, as linhas de comentários em branco e as diretivas do compilador são tratadas adequadamente. De qualquer maneira, funcionou melhor para mim com o VB.NET e o C # não testei.
user12861
^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #) ~ (: Wh @ $). + Acabou trabalhando melhor para C #, estava obtendo algumas linhas que consistiam apenas de espaço em branco.
user12861
Também não conta todas as linhas comentadas? Apenas linhas de código, por favor!
precisa saber é o seguinte
4
Aqui está um que eu criei que funciona no VS2012 (o post publicado está desatualizado em 2010) e conta apenas linhas de código. Exclui todos os comentários, usando diretivas, chaves, diretivas xml, linhas em branco, etc ... para fornecer um código verdadeiro apenas para contar: ^ (?! (\ S **)) (?! (\ S * \ - \ - \>)) (?! (\ s * \ <\! \ - \ -)) (?! (\ s * \ n)) (?! (\ s ** \ /)) (?! (\ s * \ / *)) (?! (\ s * \ / \ / \ /)) (?! (\ s * \ / \ /)) (?! (\ s * \})) (? ! (\ s * \ {)) (?! (\ s (using))). * $ #
Howard Renollet
65

cloc é uma excelente linha de comando, baseada em Perl e executável em Windows, que divide as linhas em branco, as linhas comentadas e as linhas de código fonte, agrupadas por formatos de arquivo.

Agora, ele não será executado especificamente em um arquivo de solução do VS, mas poderá ser repetido por meio de diretórios e você poderá configurar os filtros de nome de arquivo conforme desejar.

Aqui está o exemplo de saída de sua página da web:

prompt> cloc perl-5.10.0.tar.gz
    4076 arquivos de texto.
    3883 arquivos exclusivos.                                          
    1521 arquivos ignorados.

http://cloc.sourceforge.net v 1.07 T = 10.0 s (251.0 arquivos / s, 84566.5 linhas / s)
-------------------------------------------------- -----------------------------
Arquivos de idioma em branco escala de código de comentário 3ª geração. equiv
-------------------------------------------------- -----------------------------
Perl 2052 110356 112521 309778 x 4,00 = 1239112,00
C 135 18718 22862 140483 x 0,77 = 108171,91
Cabeçalho 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
fazer 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
Lote DOS 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
-------------------------------------------------- -----------------------------

A escala equivalente de terceira geração é uma estimativa aproximada de quanto código seria necessário em um idioma de terceira geração . Não é muito útil, mas interessante de qualquer maneira.

Mark Rushakoff
fonte
1
Isso é ótimo e super fácil de usar. Muito mais fácil do que as soluções Localizar / Substituir e mais claro o que está realmente fazendo do que a opção VS Code Metrics. Apenas choco install cloce, cloc .em seguida, em sua solução dir. Tarefa concluída!
Rory
1
Fiz o download do EXE do Windows no site do CLOC e o executei na pasta do projeto do site do Visual Studio 2017. Funcionou como um encanto. Eu gosto da opção - por arquivo por lang que lista a contagem de linhas por arquivo e idioma individuais, classificados do maior para o menor.
Humbads 29/0318
42

As respostas aqui estão um pouco desatualizadas, podem ser do período vs 2008. Como nas versões mais recentes do Visual Studio 2010/2012, esse recurso já está embutido. Portanto, não há razão para usar qualquer extensão ou ferramenta para isso.

Recurso para contar linhas de código - Calcular métricas. Com ele, você pode calcular suas métricas (LOC, índice de manutenção, índice ciclomático, profundidade de herança) para cada projeto ou solução.

Basta clicar com o botão direito do mouse na solução ou projeto no Solution Explorer,

insira a descrição da imagem aqui

e selecione "Calcular métricas"

insira a descrição da imagem aqui

Dados posteriores para análise e agregação podem ser importados para o Excel. Também no Excel, você pode filtrar as classes geradas ou outros ruídos de suas métricas. Essas métricas, incluindo as linhas de código LOC, podem ser coletadas também durante o processo de compilação e incluídas no relatório de compilação

Regfor
fonte
2
O Visual Studio 2010 também possui essas métricas. Na verdade, nada de novo no VS2012.
Mike Chaliy
1
Sim, mas as respostas aqui são da época de 2008 e um pouco desatualizadas, por que usar qualquer coisa ou instalar alguma extensão quando é um recurso embutido. E mesmo que não seja novidade, muitas pessoas não sabem disso.
Regfor
@MikeChaliy Pode ser a segunda frase de introdução que o confundiu, então eu o reescrevi um pouco para evitar essa confusão.
Regfor
Eu tenho uma solução de camada n, mas que exibe este erro: "Exceção foi lançada pelo destino de uma invocação." porque?
user197508
5
Isso não é linhas de código, mas Linhas compiladas (ou seja, depois que ele é transformado em IL). Eu acho que Fermin estava procurando linhas pré-compiladas.
precisa saber é o seguinte
29

As expressões regulares foram alteradas entre o VS2010 e 2012, portanto, a maioria das soluções de expressão regular aqui não funciona mais

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

Encontrará todas as linhas que não estão em branco, não são apenas um colchete ('{' ou '}') e não são apenas um #include ou outro pré-processador.

Use Ctrl- shift- fe verifique se as expressões regulares estão ativadas.

A expressão regular correspondente para o VS 2010 e anteriores é

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

No Visual Studio Team System 2008 você pode fazer a partir do menu Analisar -> 'Calcular Código Métricas para solução' e ele vai te dar uma contagem de linha de toda a sua solução de (entre outras coisas g )

Christopher Klein
fonte
12
O Visual Studio Team System 2008 não consegue contar o código não gerenciado. ;)
Christian
11

Uma solução simples é procurar em todos os arquivos. Digite "*" enquanto estiver usando curingas. O que corresponderia a todas as linhas. No final da janela de resultados da pesquisa, você verá uma linha do tipo:

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

Obviamente, isso não é muito bom para projetos grandes, pois todas as linhas são usinadas e carregadas na memória para serem dispersas na janela de resultados da pesquisa.

Referência:

Sogartar
fonte
4

Obviamente, as ferramentas são mais fáceis, mas eu me sinto bem fazendo isso no PowerShell :)

Esse script localiza todas as referências .csproj no arquivo .sln e, em cada arquivo csproj, localiza os arquivos incluídos para compilação. Para cada arquivo incluído para compilação, ele cria um objeto com propriedades: Solução, Projeto, Arquivo, Linhas. Ele armazena todos esses objetos em uma lista e, em seguida, agrupa e projeta os dados conforme necessário.

#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}
anakic
fonte
3

Use a opção Menu-> Analisar -> Calcular Métricas de Código no Visual Studio 2010 Ultimate.

tomar sol
fonte
2

Você pode usar a ferramenta gratuita SourceMonitor

Dá várias medidas: Linhas de Código, Contagem de Declarações, Complexidade, Profundidade do Bloco

Possui saídas gráficas através de gráficos

Hovhannes Hakobyan
fonte
1

Eu vim com um script de PowerShell rápido e sujo para contar linhas em uma estrutura de pastas. Ele não é tão completo quanto algumas das outras ferramentas mencionadas em outras respostas, mas acho que é bom o suficiente para fornecer uma comparação aproximada do tamanho dos arquivos de código em relação ao outro em um projeto ou solução.

O script pode ser encontrado aqui:

https://gist.github.com/1674457

Jesse Taber
fonte
0

No Visual Studio 2015, vá para o menu Analisar e selecione "Calcular métricas de código".

Atters
fonte