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

Eu achei powershell útil para isto. Eu considero LoC uma métrica bastante falsa de qualquer maneira, então eu não acredito que qualquer coisa mais formal deve ser necessária.

A partir do directó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 todas as soluções.cs and .ficheiros xaml. Para um projecto maior, acabei de usar uma lista de extensão diferente:

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

Porquê usar uma aplicação inteira quando uma única linha de comando o faz? :)

Eu usei Ctrl+Shift+f. Em seguida, coloque um \n na caixa de pesquisa e active a opção expressões regulares. Em seguida, nos resultados find, no final da tela estão o número de arquivos pesquisados e linhas de código encontrados.

Um contador de linha aberta para VS2005, 2003 e 2002 está disponível aqui:

Http://www.wndtabs.com/

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

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

Também os dispositivos de edição Slick têm um bom contador de linhas, aqui:

Http://www.slickedit.com/products/slickedit

E Microsoft Visual Studio O sistema de equipe 2008 inclui um bom contador de linha.

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

Encontrei esta dica: LOC com VS Find and replace

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

Aqui está uma atualização para o Visual Studio 2012/2013/2015 para aqueles que querem fazer a opção "Find" (que eu acho que é o mais fácil): este RegEx vai encontrar todas as linhas não-em branco com várias exclusões para dar os resultados mais precisos.

Introduza a seguinte expressão regular na caixa" Procurar". Certifique-se de seleccionar a opção "Usar Expressões Regulares". Mude a opção de pesquisa para "projeto atual" ou "solução inteira", dependendo de suas necessidades. Agora seleccione "encontrar tudo". No no fundo da janela Encontre os resultados, irá ver "linhas correspondentes" que são as linhas de contagem de códigos.

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

Esta expressão regular exclui as seguintes rubricas::

Comentários

// This is a comment

Comentários multi-linhas (assumindo que as linhas são correctamente comentadas com um * à frente de cada linha)

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

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

Comentários em HTML:

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

Utilizar declarações:

using System;
using System.Web;

Abrir Chavetas encaracoladas:

{

}

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

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

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

Agora não irá correr especificamente num ficheiro de solução VS, mas poderá percorrer as pastas e poderá configurar os filtros de nomes de ficheiros como achar melhor.

Aqui está o resultado da amostra da sua página web:

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

A escala equivalente de terceira geração é uma estimativa aproximada de quanto código que tomaria numa linguagem de terceira geração . Não muito útil,mas interessante.

As respostas aqui estão um pouco desactualizadas, podem ser do tempo vs 2008. Porque nas versões mais recentes do Visual Studio 2010/2012, este recurso já está incorporado. Assim, não há razão para usar qualquer extensão ou ferramentas para ele.

Recurso para contar linhas de código-calcular métricas. Com ele você pode calcular suas métricas (LOC, Maintaince index, Cyclomatic index, profundidade de inerência) para cada projeto ou solução.

Basta carregar com o botão direito na solução ou no projecto na solução Explorer,

E seleccione "calcular métricas"

Dados posteriores para análise e agregação podem ser importados para o Excel. Também no Excel você pode filtrar classes geradas, ou outro ruído de suas métricas. Estas métricas, incluindo linhas de código LOC, podem ser recolhidas também durante o processo de compilação, e incluídas no build report

As expressões regulares mudaram entre VS2010 e 2012, por isso a maior parte das soluções de expressão regular já não funcionam aqui

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

Irá encontrar todas as linhas que não estão em branco, não são apenas um único parêntesis ( '{' ou '}' ) e não apenas um #include ou outro pré-processador.

Usar Ctrl-shift-f e certifique-se que as expressões regulares estão activas.

A expressão regular correspondente para VS 2010 e mais antigo é

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

No Visual Studio Team System 2008, pode fazer a partir do menu Analisar-- > 'calcular as métricas de código para a solução' e dar-lhe - á uma contagem de linhas de toda a sua solução (entre outras coisas g)

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

Tem uma carga de utilitários construídos, incluindo um contador de linhas que diz quantas linhas estão em branco, Código, etc.

Uma solução simples é procurar em todos os ficheiros. Digite " * " enquanto usa wildcards. O que corresponde a todas as linhas. No final da janela de procura de resultados você deve ver uma linha do tipo:

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

Referência:

• Exemplo Avançado

Podias usar:

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

Eu prefiro métricas de Oxiproject VS Addin.

Este script encontra tudo .csproj references in the .arquivo sln, e então dentro de cada arquivo csproj ele localiza arquivos incluídos para compilação. Para cada arquivo que é 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 então 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 VS2008 (código aberto): http://www.accendo.sk/Download/SourceStat.zip

Usar o Menu - > Analisar - > calcular a opção de métricas de código no Visual Studio 2010 Ultimate.

Pode usar oVisual Studio Code Métrics PowerTool 10.0 . É um utilitário de linha de comando que calcula algumas métricas em código gerenciado para você (incluindo linhas de código). Você pode obter um 'plugin' VS 2010 que traz a ferramenta para o Visual Studio, tornando-a tão rápida como seleccionar o item do menu e carregar em "Analisar a solução."

Concordo com Ali Parr. O wndtab Line Counter addin é uma ferramenta desse tipo. http://www.codeproject.com/KB/macros/linecount.aspx

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

Pode usar a ferramenta gratuita SourceMonitor

Dá um monte de medidas: linhas de código, Contagem de declarações, complexidade, profundidade de bloco

Tem saídas gráficas via gráficos

Pode usar o contador de linha do projecto add-in No Visual Studio 2010. Normalmente não funciona com o Visual Studio 2010, mas funciona com uma ajuda.reg ficheiro a partir daqui: http://www.onemanmmo.com/index.php?cmd=newsitem&comment=news.1.41.0

O script pode ser encontrado aqui:

Https://gist.github.com/1674457