visual tutorial studio ordenar linea iconos fuente español eliminar ejemplos configurar codigo code cambiar ajuste visual-studio code-metrics lines-of-code line-count
http://neptuner.googlecode.com/files/neptuner_0_30_windows.ziphttp://www.accendo.sk/Download/SourceStat.zip

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



visual studio code ejemplos (25)

Aquí está el truco ... Cuenta el archivo Js también.

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

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

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

Ingrese el siguiente RegEx en el cuadro "Buscar". Por favor, 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 selecciona "Buscar todos". En la parte inferior de la ventana Resultados de la búsqueda , verá "Líneas coincidentes", que es el número de líneas del código.

^(?!(/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 multilínea (suponiendo que las líneas se comentan correctamente con un * al frente 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 las 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 que no están 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 me quedo 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.

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

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 su solución completa (entre otras cosas g )

He encontrado útil powershell para esto. Considero que LoC es una métrica bastante falsa de todos modos, por lo que no creo que se requiera algo más formal.

Desde el 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 que no estén 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á? :)

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 sean solo un corchete (''{'' o ''}'') y no solo un #include u otro preprocesador.

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

Las respuestas aquí están un poco desactualizadas, pueden ser desde la hora de 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 herramienta 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 de Cyclomatic, 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 se podrían importar 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

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

Esta secuencia de comandos encuentra todas las referencias .csproj 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}

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

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

Puede utilizar la herramienta gratuita SourceMonitor

Ofrece muchas medidas: líneas de código, recuento de estados de cuenta, complejidad, profundidad de bloque.

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

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 relacionados entre sí en un proyecto o solución.

El script se puede encontrar aquí:

https://gist.github.com/1674457

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

http://www.wndtabs.com/

También hay una discusión sobre la creación de un complemento de VS de conteo de líneas, completo con código en Codeproject, aquí

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

También los gadgets Slick Edit tienen 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í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 aviones por peso. Bill Gates

Una solución simple es buscar en todos los archivos. Escribe "*" mientras usas 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 orden:

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 mecanizan y se cargan en la memoria para que se muestren en la ventana de resultados.

Referencia:

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

Utilicé Ctrl + Shift + F. A continuación, ponga un /n en 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 encuentran la cantidad de archivos buscados y las líneas de código encontradas.

Visual Studio 2010 Ultimate tiene este incorporado.

Analizar -> Calcular las métricas de código

cloc es una excelente línea de comando, basada en Perl, ejecutable de Windows 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 repartirse 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 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 cuánto código tomaría en un lenguaje de tercera generación . No es terriblemente útil, pero interesante de todos modos.