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

É 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?

O Visual Studio 2010 Ultimate possui este built-in:

Analisar → Calcular métricas de código

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

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

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

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.

Encontrou esta dica: LOC with VS Localizar e substituir

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

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.

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,

e selecione "Calcular métricas"

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

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

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 )

Para futuros leitores, gostaria de aconselhar a extensão DPack para o Visual Studio 2010 .

Ele possui vários utilitários incorporados, incluindo um contador de linhas que indica quantas linhas estão em branco, código e etc.

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:

• Exemplo Avançado

Você poderia usar:

• SCLOCCount http://www.dwheeler.com/sloccount/ - Código aberto
• local métricas, http://www.locmetrics.com/ - não é de código aberto, mas é fácil de usar

Prefiro o OxyProject Metrics VS Addin .

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}

Outra ferramenta simples para o VS2008 (código aberto): http://www.accendo.sk/Download/SourceStat.zip

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

Você pode usar as métricas de código do Visual Studio PowerTool 10.0 . É um utilitário de linha de comando que calcula algumas métricas no código gerenciado para você (incluindo linhas de código). Você pode obter um plug-in do VS 2010 que traz a ferramenta para o Visual Studio e a torna tão rápida quanto selecionar o item de menu e clicar em "Analisar Solução".

Concordo com Ali Parr. O complemento WndTab Line Counter é uma dessas ferramentas. http://www.codeproject.com/KB/macros/linecount.aspx

Também é uma boa ideia pesquisar no site de download para encontrar alguma ferramenta relacionada. http://www.cnet.com/1770-5_1-0.html?query=code+counter&tag=srch

Aqui está o truque. Também conta o arquivo Js.

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

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

Você pode usar o suplemento Contador de Linha do Projeto no Visual Studio 2010. Normalmente, ele não funciona com o Visual Studio 2010, mas com um arquivo .reg útil a partir daqui: http://www.onemanmmo.com/index. php? cmd = newsitem & comment = news.1.41.0

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

Tente neptuner. Também fornece itens como espaços, guias, linhas de comentários, além do LoC. http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip

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