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


800

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


24
Estoy de acuerdo que no ayuda mucho, pero si la administración está pidiendo que ...
Fermín

33
LoC es simplemente una métrica y es particularmente interesante en 2 casos: 1) para tener una idea de cuán grande es la base del código, es decir, cuando te unes a un nuevo equipo 2) para medir tu progreso al intentar hacer tu base de código más compacta
Piotr Owsiak

191
Algunas personas aquí dicen que contar líneas de código es inútil sin pensarlo bien. Es bastante útil ya que es una métrica que generalmente debe minimizarse. Es una manera simple de medir la complejidad de la solución (no la eficiencia) y si se sabe que el problema es simple, cuantas más líneas de código, generalmente, menor será la calidad. Otra cosa es ¿por qué la gente se molesta en responder si es solo para decir que la pregunta es mala? ¿Qué pensarías si un maestro te dijera que tu pregunta no debería hacerse?

77
En VS2010 hay una herramienta integrada que también cuenta todas las líneas de código y otros valores: vaya a Ver -> Otras ventanas -> Resultados de métricas de código. Un pequeño botón en la esquina que parece un calendario, haga clic en eso, la información sobre herramientas debería decir Calcular métricas de código para soulution, y dejar que VS haga lo suyo.
user959631

64
La persona no siempre necesita decirle por qué quiere contar el código. Cuando la pregunta es simple, el caso sobre por qué es irrelevante. Solo responde su pregunta. Odio eso. Hay momentos para preguntar por qué cuando claramente lo necesitas y luego hay veces que no lo haces (cuando personalmente no ves una necesidad ... y simplemente estás fastidiando el cartel con arrogancia).
PositiveGuy

Respuestas:


525

Visual Studio 2010 Ultimate tiene este incorporado:

Analizar → Calcular métricas de código


12
Ultimate y Premium, creo
Stefan Dragnev

39
Advertencia: Esto hace muchas otras cosas además de simplemente contar líneas. También enumera el "Índice de mantenimiento", la "Complejidad ciclomática", la "Profundidad de la herencia" y el "Acoplamiento de clase", todos los cuales son bastante complicados de calcular, y no puede ejecutar las métricas para solo una parte. Lo que esto significa es que si su base de código es particularmente grande, puede estar sentado durante horas esperándolo. Si todo lo que desea es contar líneas, hay soluciones mucho más rápidas.
Darrel Hoffman

44
también en vs2012 ultimate =)
oCcSking

99
VS 2013 tiene Análisis -> Calcular métricas de código
Dinesh Rajan

42
Lástima que esto no funcione con proyectos nativos de C ++ (al menos no lo hace en VS2013).
Cameron

844

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


19
(La única vez que me pidieron que contara líneas de suministro fue cuando la alta gerencia calculaba cuánto tiempo tomaría migrar todos nuestros productos al extranjero para que pudieran cerrar nuestro sitio doméstico).
Greg D

8
(Sí, esto incluye archivos codegen'd y comentarios. No, eso no me molesta. Los diseñadores, el código gen'd y los comentarios también deben mantenerse.)
Greg D

27
muy agradable, se olvidó por completo de powershell. debería convertirse en reemplazo predeterminado para cmd
lubos hasko

44
¡Excelente! Su comentario final realmente lo resume, es una tarea trivial, entonces, ¿por qué usar una herramienta no trivial? Aunque realmente creo que debería incluirse en todas las versiones de VS.
Sune Rievers

13
Si desea excluir los archivos de respaldo generados para XAML, simplemente puede agregar un modificador -exclude: (dir -exclude *.g.cs -include *.cs,*.xaml -recurse | select-string .).Count
EZ Hart

349

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


16
Esta solución incluye incorrectamente líneas en blanco, comentarios, documentación y declaraciones divididas. Para muchas aplicaciones, esas no deben contar como líneas de código.
Jay Baxter

1
Aunque es un poco inexacto (si realmente usa \ n en su código, esa línea se contará dos veces), sigue siendo la mejor respuesta si necesita una ROM de líneas de código sin una herramienta de terceros
Joseph Duty

1
También puede seleccionar un tipo de archivo específico seleccionando un Look at these file types:menú desplegable de opciones debajo de enable regular expressions box.
Moshii

1
Funciona para proyectos muy pequeños ... cuando tiene 100 millones de líneas de código, esto llevará algún tiempo.
pantano

11
[^\n\s]\r\nomite líneas en blanco, incluso con espacios en ellas.
Zach Mierzejewski

219

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


1
A menudo, el recuento de líneas de código es simplemente tonto, y la cantidad no implica calidad. Sin embargo, un gran equipo que lanza un Dreamliner de 545,000 lb (545,000 lb !!) en el aire es un logro completamente diferente al lanzamiento del ultralite que construí solo en mi garaje. Y si piensa en la cantidad de líneas de código en Windows, ¿tal vez el Sr. Bill lo dijo de una manera diferente a la que generalmente se toma ...?
Incondicionalmente

18
Ninguno de estos parece aplicarse a Visual Studio 2010, y el enlace slickedit está roto.
MGOwen

57
Encontrará la función LOC en Visual Studio 2010 Ultimate en "Análisis> Métricas de código" . Espero haberla traducido correctamente. Tengo la versión alemana Ahí está "Analizar"> "Codemetriken berechnen"
OneWorld

2
para Visual Studio 2012, la métrica de LoC se puede encontrar en ANALIZAR> Calcular métricas de código para la solución
tetri

2
Además, VS2012 incluye esta característica en las ediciones Ultimate y Premium (y ahora también en Professional).
SWalters - Restablece a Mónica el

81

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.


18
Me encanta el voto negativo sin comentarios. Esto no debería permitirse. ¿Qué pasa con mi solución no funciona? Ni siquiera me importan los votos, solo quería publicar una actualización para los usuarios de VS2012-2013.
Howard Renollet

Es difícil filtrar todo el código generado (información de ensamblaje, etc.), por lo que debe preferirse Analizar / Calcular métricas de código.
MKesper

44
Buen trabajo, pero mencione la casilla de verificación Usar expresión regular en la sección Opciones de búsqueda . Lo hace mucho más fácil
Gogutz

@MKesper PERO ESO NO FUNCIONA PARA C ++
d7samurai

Una versión más simple si no hay XML, ni HTML ... ^ (? ([^ \ R \ n]) \ s) * [^ \ s +? /] + [^ \ N] * $.
LastBlow

80

Encontré este consejo: LOC con VS Buscar y reemplazar

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


Me encanta este, pero creo que encontré un pequeño error en la expresión allí. Para VB.Net creo que debería ser ^ ~ (: Wh @ ') ~ (: Wh @ \ #). + Y para C # creo que ^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #). + De esta forma, las líneas de comentarios en blanco y las directivas del compilador se tratan correctamente. Me funcionó mejor con VB.NET de todos modos, y C # no lo he probado.
user12861

^ ~ (: Wh @ //) ~ (: Wh @ \ {: Wh @) ~ (: Wh @ \}: Wh @) ~ (: Wh @ \ #) ~ (: Wh @ $). + Terminó trabajando mejor para C #, estaba obteniendo algunas líneas que consisten solo en espacios en blanco.
user12861

¿No cuenta todas las líneas comentadas también? ¡Solo líneas de CÓDIGO por favor!
HydPhani

44
Aquí hay uno con el que creé que funciona en VS2012 (el que está publicado está desactualizado a partir de 2010) y solo cuenta líneas de código. Se excluyen todos los comentarios, el uso de directivas, llaves, directivas xml, líneas en blanco, etc. - \ - \>)) (?! (\ s * \ <\! \ - \ -)) (?! (\ s * \ n)) (?! (\ s ** \ /)) (?! (\ s * \ / *)) (?! (\ s * \ / \ / \ /)) (?! (\ s * \ / \ /)) (?! (\ s * \})) (? ! (\ s * \ {)) (?! (\ s (using))). * $
Howard Renollet

65

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.


1
Esto es genial y súper fácil de usar. Mucho más fácil que las soluciones Buscar / Reemplazar y más claro lo que realmente está haciendo que la opción VS Code Metrics. Justo choco install clocy luego cloc .en su solución dir. ¡Trabajo hecho!
Rory

1
Descargué el EXE de Windows del sitio web de CLOC y lo ejecuté en mi carpeta de proyecto del sitio web de Visual Studio 2017. Trabajado como un encanto. Me gusta la opción --by-file-by-lang que enumera el recuento de líneas por archivo e idioma individual, ordenados de mayor a menor.
Humbads

42

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,

ingrese la descripción de la imagen aquí

y seleccione "Calcular métricas"

ingrese la descripción de la imagen aquí

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


2
Visual Studio 2010 también tiene estas métricas. En realidad, nada nuevo en VS2012 en absoluto.
Mike Chaliy

1
Sí, pero las respuestas aquí son de la época de 2008 y un poco desactualizadas, ¿por qué usar algo o instalar alguna extensión cuando es una característica incorporada? E incluso no es una característica nueva que mucha gente desconoce.
Regor

@MikeChaliy Puede que la segunda oración de introducción te haya confundido, así que lo he reescrito un poco para evitar esa confusión.
Regor

Tengo una solución de n capas pero que muestra este error: "El destino de una invocación ha lanzado una excepción". ¿por qué?
user197508

55
No se trata de líneas de código, sino de líneas compiladas (es decir, después de que se convierte en IL). Creo que Fermín estaba buscando líneas precompiladas.
mikeschuld

29

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

19

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 )


12
Visual Studio Team System 2008 no logra contar el código no administrado. ;)
Christian


11

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:




4

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}


3

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





2

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.



1

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



0

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.