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

¿Es posible encontrar el número de líneas de código en una solución completa? He oído hablar de MZ-Tools , pero ¿hay un equivalente de código abierto?

Visual Studio 2010 Ultimate tiene este incorporado:

Analizar → Calcular métricas de código

He encontrado powershell útil para esto. Considero que LoC es una métrica bastante falsa de todos modos, por lo que no creo que deba exigirse 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>

Eso contará las líneas no en blanco en todos los archivos .cs y .xaml de la solución. Para un proyecto más grande, acabo de usar 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á? :)

Yo usé Ctrl+ Shift+ F. A continuación, coloque un \nen el cuadro de búsqueda y active el cuadro de expresiones regulares. Luego, en los resultados de búsqueda, al final de la pantalla, se encuentra el número de archivos buscados y las líneas de código encontradas.

Puede usar [^\n\s]\r\npara omitir líneas en blanco y solo espacio (créditos a Zach en los comentarios).

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

http://www.wndtabs.com/

También se está discutiendo la creación de un complemento de conteo de líneas VS, completo con código en Codeproject, aquí

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

También Slick Edit Gadgets tiene un buen contador de líneas, aquí:

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

y Microsoft Visual Studio Team System 2008 incluye un buen contador de línea.

Pero recuerda:

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

Aquí hay una actualización para Visual Studio 2012/2013/2015 para aquellos que desean hacer la opción "Buscar" (que creo que es la más fácil): este RegEx encontrará todas las líneas no en blanco con varias exclusiones para obtener los resultados más precisos .

Ingrese el siguiente RegEx 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ódigos.

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

Este RegEx excluye los siguientes elementos:

Comentarios

// This is a comment

Comentarios de varias líneas (suponiendo que las líneas están correctamente comentadas 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>

Comentarios HTML:

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

Usando declaraciones:

using System;
using System.Web;

Apertura de llaves:

{

Cierre de llaves:

}

Nota: cualquier cosa entre llaves se incluiría en la búsqueda, pero en este ejemplo solo contarían 4 líneas de código, 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 lo compartiría. A los jefes les encantan las cuentas de LOC, así que estoy atascado con eso por un tiempo. Espero que alguien más pueda encontrar esto útil, avíseme si tiene alguna pregunta o necesita ayuda para que funcione.

Encontré este consejo: LOC con VS Buscar y reemplazar

Sin embargo, no es un complemento si eso es lo que estás buscando.

cloc es una excelente línea de comandos, ejecutable de Windows basada en Perl que desglosará 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 repetirse a través de directorios y puede configurar filtros de nombre de archivo como mejor le parezca.

Aquí está la salida de muestra de su página web:

prompt> cloc perl-5.10.0.tar.gz
    4076 archivos de texto.
    3883 archivos únicos.                                          
    1521 archivos ignorados.

http://cloc.sourceforge.net v 1.07 T = 10.0 s (251.0 archivos / s, 84566.5 líneas / s)
-------------------------------------------------- -----------------------------
Lenguaje archivos en blanco código de comentario escala 3ra generación equiv
-------------------------------------------------- -----------------------------
Perl 2052 110356 112521 309778 x 4.00 = 1239112.00
C 135 18718 22862 140483 x 0.77 = 108171.91
Encabezado 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
hacer 7 498 473 2044 x 2.50 = 5110.00
C ++ 10 312 277 2000 x 1.51 = 3020.00
XML 26231 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 50322 x 0.63 = 202.86
HTML 1 19 2 98 x 1.90 = 186.20
-------------------------------------------------- -----------------------------
SUMA: 2510 142085 156406 547174 x 2.84 = 1556285.03
-------------------------------------------------- -----------------------------

La escala equivalente de tercera generación es una estimación aproximada de cuánto código tomaría en 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 de vs 2008. Porque en las versiones más nuevas 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 puede calcular sus métricas (LOC, índice de mantenimiento, índice ciclomático, profundidad de herencia) para cada proyecto o solución.

Simplemente haga clic derecho en la solución o proyecto en el Explorador de soluciones,

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 expresiones regulares aquí ya no funcionan

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

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

Use Ctrl- shift- fy 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 puede hacerlo desde el menú Analizar -> 'Calcular métricas de código para la solución' y le dará un recuento de líneas de toda su solución (entre otras cosas g )

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

Tiene una gran cantidad de utilidades incorporadas, incluido un contador de líneas que dice cuántas líneas están en blanco, código, etc.

Una solución simple 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 combinan y se cargan en la memoria para mostrarlas en la ventana de resultados de búsqueda.

Referencia:

• Ejemplo avanzado

Podrías usar:

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

Prefiero OxyProject Metrics VS Addin.

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

Este script encuentra todas las referencias .csproj en el archivo .sln y luego, dentro de cada archivo csproj, ubica los archivos incluidos para su 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 simple para VS2008 (código abierto): http://www.accendo.sk/Download/SourceStat.zip

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

Puede usar Visual Studio Code Metrics PowerTool 10.0 . Es una utilidad de línea de comandos que calcula algunas métricas sobre el código administrado por 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 del menú y hacer clic en "Analizar solución".

De acuerdo con Ali Parr. El complemento WndTab Line Counter es una herramienta de este tipo. http://www.codeproject.com/KB/macros/linecount.aspx

También es una buena idea buscar desde el sitio de descarga 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

Puedes usar la herramienta gratuita SourceMonitor

Da muchas medidas: líneas de código, recuento de declaraciones, complejidad, profundidad de bloque

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

Puede usar el complemento Project Line Counter en Visual Studio 2010. Normalmente no funciona con Visual Studio 2010, pero sí 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 como para proporcionar una comparación aproximada del tamaño de los archivos de código entre sí en un proyecto o solución.

El script se puede encontrar aquí:

https://gist.github.com/1674457

Prueba neptuner. También le ofrece 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".