Como você conta as linhas de código em uma solução Visual Studio?
25 answers
Analisar - > Calcular Métricas De Código
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:
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.
Mas lembra-te: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 */
XML for Intellisense
/// <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:
{
Fechando 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 */
}
}
Eu criei isso para me dar uma contagem de LOC muito mais precisa do que algumas opções anteriores, e pensei que eu iria compartilhar. Os chefes adoram LOC conta, por isso vou ficar com ele por uns tempos. Espero que alguém possa achar isso útil, me avise se você tiver alguma dúvida ou precisar de Ajuda para fazê-lo funcionar.
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:
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
Também é uma boa ideia procurar no site de download para encontrar alguma ferramenta relacionada. http://www.cnet.com/1770-5_1-0.html?query=code+contador&tag=srchHttp://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: