¿Cómo se cuentan las líneas de código en una solución de Visual Studio?

He encontrado powershell útil para esto. Considero que LoC es una métrica bastante falsa de todos modos, así que no creo que se deba requerir nada más formal.

Del directorio de una solución pequeña:

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

Que contará las líneas no en blanco en todas las soluciones .cs y .archivos xaml. Para un proyecto más grande, solo usé una lista de extensiones diferente:

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

¿Por qué usar una aplicación completa cuando una sola línea de comandos lo hará? :)

He usado Ctrl+Cambio+F. A continuación, ponga un \n en el cuadro de búsqueda y habilitar expresiones regulares caja. Luego, en los resultados de búsqueda, al final de la pantalla están el número de archivos buscados y las líneas de código encontradas.

Un contador de líneas de código abierto para VS2005, 2003 y 2002 está disponible aquí:

Http://www.wndtabs.com/

También se discute la creación de un conteo de líneas VS addin, completo con código en Codeproject, aquí

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

También los Gadgets de edición tienen un buen contador de líneas, aquí:

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

Y El Equipo de Microsoft Visual Studio System 2008 incluye un buen contador de líneas.

Pero recuerda:

Medir el progreso de la programación por líneas de código es como medir el progreso de la construcción de aeronaves por peso. Bill Gates

Encontré este consejo: LOC con VS Buscar y reemplazar

No es un plugin aunque si eso es lo que estás buscando.

Aquí hay una actualización para Visual Studio 2012/2013/2015 para aquellos que quieran hacer la opción "Buscar" (que me parece que es la más fácil): Esta expresión regular encontrará todas las líneas no en blanco con varias exclusiones para dar los resultados más precisos.

Introduzca la siguiente expresión regular en el cuadro "Buscar". Asegúrese de seleccionar la opción" Usar expresiones regulares". Cambie la opción de búsqueda a "Proyecto actual" o "Solución completa" según sus necesidades. Ahora seleccione "Buscar todo". En la parte inferior de la ventana Buscar resultados, verá "Líneas coincidentes" que son las líneas de recuento de código.

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

Esta expresión regular excluye los siguientes elementos:

Comentarios

// This is a comment

Comentarios multilínea (suponiendo que las líneas se comentan correctamente con un * delante de cada línea)

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

XML para Intellisense

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

HTML Comentarios:

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

Usando declaraciones:

using System;
using System.Web;

Apertura de llaves:

{

Cierre de llaves:

}

Nota: cualquier cosa entre las llaves se incluiría en la búsqueda, pero en este ejemplo solo 4 líneas de código contarían, en lugar de 18 líneas reales no en blanco:

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

Creé esto para darme un recuento de LOC mucho más preciso que algunas opciones anteriores, y pensé que compartiría. A los jefes les encanta LOC counts, así que me quedo con él por un tiempo. Me espero que alguien más pueda encontrar esto útil, hágamelo saber si tiene alguna pregunta o necesita ayuda para que funcione.

Cloc es una excelente línea de comandos, basada en Perl, ejecutable de Windows que descompondrá las líneas en blanco, las líneas comentadas y las líneas de código fuente, agrupadas por formatos de archivo.

Ahora no se ejecutará específicamente en un archivo de solución VS, pero puede recurrir a través de directorios, y puede configurar filtros de nombre de archivo como mejor le parezca.

Aquí está el ejemplo de salida de su 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
-------------------------------------------------------------------------------

La escala equivalente de tercera generación es una estimación aproximada de la cantidad de código que tomaría un lenguaje de tercera generación . No es terriblemente útil, pero interesante de todos modos.

Las respuestas aquí están un poco desactualizadas, pueden ser del tiempo vs 2008. Debido a que en las versiones más recientes de Visual Studio 2010/2012, esta característica ya está incorporada. Por lo tanto, no hay razón para usar ninguna extensión o herramientas para ello.

Característica para contar líneas de código - Calcular métricas. Con él podrás calcular tus métricas (LOC, índice de Mantenimiento, índice ciclomático, Profundidad de herencia) para cada proyecto o solución.

Simplemente haga clic derecho en solución o proyecto en Solución Explorador,

Y seleccione "Calcular métricas"

Los datos posteriores para el análisis y la agregación podrían importarse a Excel. También en Excel puede filtrar las clases generadas u otro ruido de sus métricas. Estas métricas, incluidas las Líneas de código LOC, podrían recopilarse también durante el proceso de compilación e incluirse en el informe de compilación

Las expresiones regulares han cambiado entre VS2010 y 2012, por lo que la mayoría de las soluciones de expresión regular aquí ya no funcionan

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

Encontrará todas las líneas que no están en blanco, no son solo un corchete ( '{' o '}' ) y no solo un #include u otro preprocesador.

Usar Ctrl-shift-f y asegúrese de que las expresiones regulares estén habilitadas.

La expresión regular correspondiente para VS 2010 y anteriores es

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

En Visual Studio Team System 2008 puedes hacer desde el menú Analizar Analyze> 'Calcular Métricas de código para la solución' y te dará un recuento de líneas de toda tu solución (entre otras cosas g)

Para futuros lectores me gustaría aconsejar la extensión DPack para Visual Studio 2010.

Tiene un montón de utilidades integradas que incluyen un contador de líneas que dice cuántas líneas están en blanco, código, etc.

Una solución sencilla es buscar en todos los archivos. Escriba " * " mientras usa comodines. Que coincidiría con todas las líneas. Al final de la ventana de resultados de búsqueda debería ver una línea del tipo:

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

Por supuesto, esto no es muy bueno para proyectos grandes, ya que todas las líneas se mached y se cargan en la memoria para ser despachadas en la ventana de resultados de búsqueda.

Referencia:

• Ejemplo Avanzado

Podrías usar:

• SCLOCCount http://www.dwheeler.com/sloccount / - Código abierto
• métricas de loc, http://www.locmetrics.com / - no es de código abierto, pero fácil de usar

Prefiero Métricas de OxyProject VS Addin.

Obviamente las herramientas son más fáciles, pero me siento genial haciendo esto en powershell:)

Este script encuentra todos los .csproj referencias en el .archivo sln, y luego dentro de cada archivo csproj localiza los archivos incluidos para la compilación. Para cada archivo que se incluye para la compilación crea un objeto con propiedades: Solución, Proyecto, Archivo, Líneas. Almacena todos estos objetos en una lista, y luego agrupa y proyecta los datos según sea necesario.

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

Otra herramienta sencilla Para VS2008 (código abierto): http://www.accendo.sk/Download/SourceStat.zip

Utilice la opción Menú-> Analizar - > Calcular métricas de código en Visual Studio 2010 Ultimate.

Puede utilizar las métricas de código de Visual Studio PowerTool 10.0 . Es una utilidad de línea de comandos que calcula algunas métricas en el código administrado para usted (incluidas las líneas de código). Puede obtener un complemento VS 2010 que trae la herramienta a Visual Studio, y lo hace tan rápido como seleccionar el elemento de menú y hacer clic en "Analizar solución."

De acuerdo con Ali Parr. El WndTab Line Counter addin es una de estas herramientas. http://www.codeproject.com/KB/macros/linecount.aspx

También es una buena idea buscar desde el sitio de descargas para encontrar alguna herramienta relacionada. http://www.cnet.com/1770-5_1-0.html?query=code + counter & tag = srch

Aquí está el Truco.. También cuenta el archivo Js.

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

Puede utilizar la herramienta gratuita SourceMonitor

Da muchas medidas: Líneas de Código, Recuento de Sentencias, Complejidad, Profundidad de Bloque

Tiene salidas gráficas a través de gráficos

Puede utilizar el complemento Project Line Counter en Visual Studio 2010. Normalmente no funciona con Visual Studio 2010, pero lo hace con un útil.archivo reg desde aquí: http://www.onemanmmo.com/index.php?cmd=newsitem&comment=news.1.41.0

Se me ocurrió un script de Powershell rápido y sucio para contar líneas en una estructura de carpetas. No es tan completo como algunas de las otras herramientas a las que se hace referencia en otras respuestas, pero creo que es lo suficientemente bueno para proporcionar una comparación aproximada del tamaño de los archivos de código en relación entre sí en un proyecto o solución.

El script se puede encontrar aquí:

Https://gist.github.com/1674457

Prueba neptuner. También le da cosas como espacios, pestañas, Líneas de comentarios, además de LoC. http://neptuner.googlecode.com/files/neptuner_0_30_windows.zip

En Visual Studio 2015 vaya al menú Analizar y seleccione "Calcular métricas de código".