¿Puedo incrementar automáticamente la versión de compilation de files cuando uso Visual Studio?

Me preguntaba cómo podría boost automáticamente la compilation (¿y la versión?) De mis files usando Visual Studio (2005).

Si busco las properties de, por ejemplo, C:\Windows\notepad.exe , la pestaña Versión da "Versión del file: 5.1.2600.2180". Me gustaría get estos numbers geniales en la versión de mi dll también, no en la versión 1.0.0.0, que admitámoslo es un poco aburrido.

Intenté algunas cosas, pero no parece ser una funcionalidad list para usar, o tal vez estoy buscando en el lugar equivocado (como de costumbre).

Trabajo principalmente con proyectos web …

Miré a ambos:

  1. http://www.codeproject.com/KB/dotnet/Auto_Increment_Version.aspx
  2. http://www.codeproject.com/KB/dotnet/build_versioning.aspx

y no podía creer que tanto esfuerzo por hacer algo sea una práctica estándar.

EDITAR: No funciona en VS2005 hasta donde yo sepa ( http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx )

En visual Studio 2008, lo siguiente funciona.

Busque el file AssemblyInfo.cs y encuentre estas 2 líneas:

 [assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")] 

Puedes intentar cambiar esto a:

 [assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyFileVersion("1.0.*")] 

Pero esto no le dará el resultado deseado, terminará con una versión de producto de 1.0. * Y una versión de file de 1.0.0.0 . ¡No es lo que quieres!

Sin embargo, si elimina la segunda de estas líneas y solo tiene:

 [assembly: AssemblyVersion("1.0.*")] 

Luego, el comstackdor configurará la versión del file para que sea igual a la versión del producto y obtendrá el resultado deseado de un producto de incremento automático y una versión de file que estén sincronizados. Ej. 1.0.3266.92689

abra el file AssemblyInfo.cs y cambie

 // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: // [assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")] 

a

 [assembly: AssemblyVersion("1.0.*")] //[assembly: AssemblyFileVersion("1.0.0.0")] 

puedes hacer esto en IDE yendo a project -> properties -> assembly information

Sin embargo, esto solo le permitirá incrementar automáticamente la versión de ensamblado y le dará el

Versión del file de ensamblaje: no se permite un comodín ("*") en este campo

cuadro de post si intenta colocar un * en el campo de la versión del file.

Así que abra el assemblyinfo.cs y hágalo manualmente.

Otra opción para cambiar los numbers de versión en cada compilation es usar la tarea Versión de MSBuild.Community.Tasks . Simplemente descargue su instalador, instálelo, luego adapte el siguiente código y péguelo después de <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> en su file .csproj :

 <Import Project="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets" /> <Target Name="BeforeBuild"> <Version VersionFile="Properties\version.txt" Major="1" Minor="0" BuildType="Automatic" StartDate="12/31/2009" RevisionType="BuildIncrement"> <Output TaskParameter="Major" PropertyName="Major" /> <Output TaskParameter="Minor" PropertyName="Minor" /> <Output TaskParameter="Build" PropertyName="Build" /> <Output TaskParameter="Revision" PropertyName="Revision" /> </Version> <AssemblyInfo CodeLanguage="CS" OutputFile="Properties\VersionInfo.cs" AssemblyVersion="$(Major).$(Minor)" AssemblyFileVersion="$(Major).$(Minor).$(Build).$(Revision)" /> </Target> 

Nota: Adapte la propiedad StartDate a su configuration regional. Actualmente no usa la cultura invariante.

Para la tercera compilation del 14 de enero de 2010, esto crea un VersionInfo.cs con este contenido:

 [assembly: AssemblyVersion("1.0")] [assembly: AssemblyFileVersion("1.0.14.2")] 

Este file se debe agregar al proyecto (a través de Agregar elemento existente ) y las líneas AssemblyVersion y AssemblyFileVersion deben eliminarse de AssemblyInfo.cs .

Los diferentes algorithms para cambiar los componentes de la versión se describen en $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm y Propiedades de la versión .

Se me ocurrió una solución similar a los cristianos, pero sin depender de las tareas de Community MSBuild, esta no es una opción para mí, ya que no quiero instalar estas tareas para todos nuestros desarrolladores.

Estoy generando código y comstackndo a un Ensamblaje y quiero incrementar automáticamente los numbers de versión. Sin embargo, no puedo usar el truco VS 6.0. * AssemblyVersion ya que aumenta automáticamente los numbers de compilation cada día y rompe la compatibilidad con los ensamblajes que usan un número de compilation anterior. En cambio, quiero tener una AssemblyVersion codificada pero una AssemblyFileVersion de incremento automático. Lo he logrado especificando AssemblyVersion en AssemblyInfo.cs y generando un VersionInfo.cs en MSBuild como este,

  <PropertyGroup> <Year>$([System.DateTime]::Now.ToString("yy"))</Year> <Month>$([System.DateTime]::Now.ToString("MM"))</Month> <Date>$([System.DateTime]::Now.ToString("dd"))</Date> <Time>$([System.DateTime]::Now.ToString("HHmm"))</Time> <AssemblyFileVersionAttribute>[assembly:System.Reflection.AssemblyFileVersion("$(Year).$(Month).$(Date).$(Time)")]</AssemblyFileVersionAttribute> </PropertyGroup> <Target Name="BeforeBuild"> <WriteLinesToFile File="Properties\VersionInfo.cs" Lines="$(AssemblyFileVersionAttribute)" Overwrite="true"> </WriteLinesToFile> </Target> 

Esto generará un file VersionInfo.cs con un atributo de ensamblaje para AssemblyFileVersion donde la versión sigue el esquema de YY.MM.DD.TTTT con la date de compilation. Debe include este file en su proyecto y comstackr con él.

Instale el complemento Build Version Increment . Le da mucho más control que la opción *.

Para get los numbers de versión, intente

  System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly(); System.Reflection.AssemblyName assemblyName = assembly.GetName(); Version version = assemblyName.Version; 

Para establecer el número de versión, cree / edite AssemblyInfo.cs

  [assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyFileVersion("1.0.*")] 

También como nota al margen, el tercer número es el número de días desde el 2/1/2000 y el cuarto número es la mitad de la cantidad de segundos totales en el día. Entonces, si comstack a medianoche, debería ser cero.

Establecer un * en el número de versión en AssemblyInfo o en las properties del proyecto como se describe en las otras publicaciones no funciona con todas las versiones de Visual Studio / .NET.

Afaik no funcionó en VS 2005 (pero en VS 2003 y VS 2008). Para VS 2005, podría usar lo siguiente: Aumentar automáticamente el número de versión y revisión de la versión de Visual Studio 2005 en time de compilation .

Pero tenga en count que no se recomienda cambiar el número de versión automáticamente para ensamblajes de nombre seguro. El motivo es que todas las references a dicho ensamblaje deben actualizarse cada vez que se reconstruye el ensamblado al que se hace reference debido al hecho de que las references de ensamblado de nombre fuerte siempre son una reference a una versión de ensamblaje específica. Los propios Microsoft cambian el número de versión de los ensamblados de .NET Framework solo si hay cambios en las interfaces. (Nota: todavía estoy buscando el enlace en MSDN donde lo leí).

Establezca el número de versión en "1.0. *" Y automáticamente completará los dos últimos numbers con la date (en días desde algún punto) y la hora (la mitad de los segundos desde la medianoche)

Hay una extensión de estudio visual Automatic Versions que admite Visual Studio 2012, 2013, 2015 y 2017.

Capturas de pantalla enter image description here

enter image description here

Para get información incremental (DateTime) en la propiedad AssemblyFileVersion, que tiene la ventaja de no romper ninguna dependencia.


Basándome en la solución de Boog (¿no funcionó para mí, quizás debido a VS2008?), Puede usar una combinación de un evento previo a la creación generando un file, agregando ese file (incluyendo sus properties de versión) y luego usando una forma de leer esos valores de nuevo. Es decir..

Pre-Build-Event:

 echo [assembly:System.Reflection.AssemblyFileVersion("%date:~-4,4%.%date:~-7,2%%date:~-10,2%.%time:~0,2%%time:~3,2%.%time:~-5,2%")] > $(ProjectDir)Properties\VersionInfo.cs 

Incluya el file VersionInfo.cs resultante (subcarpeta Propiedades) en su proyecto

Código para recuperar la date (de años a segundos):

 var version = assembly.GetName().Version; var fileVersionString = System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location).FileVersion; Version fileVersion = new Version(fileVersionString); var buildDateTime = new DateTime(fileVersion.Major, fileVersion.Minor/100, fileVersion.Minor%100, fileVersion.Build/100, fileVersion.Build%100, fileVersion.Revision); 

No muy cómodo … también, no sé si crea muchas reconstrucciones de fuerza (ya que un file siempre cambia).

Podría hacerlo más inteligente, por ejemplo, si solo actualiza el file VersionInfo.cs cada pocos minutos / horas (utilizando un file temporal y luego copyndo / sobrescribiendo el verdadero VersionInfo.cs si se detecta un cambio lo suficientemente grande). Hice esto una vez con bastante éxito.

Está en las properties de su proyecto en Publicar

http://screencast.com/t/Vj7rhqJO
(~ http://screencast.com/t/Vj7rhqJO )

Ir a Proyecto | Propiedades y luego Información de ensamblaje y luego Versión de ensamblaje y coloque un * en el último cuadro o el penúltimo (no puede boost automáticamente los componentes Mayor o Menor).

Cake admite el parche de files AssemblyInfo. Con la torta en las manos, tienes forms infinitas de implementar la versión automática incrementada.

El ejemplo simple de la versión de incremento como el comstackdor C # hace:

 Setup(() => { // Executed BEFORE the first task. var datetimeNow = DateTime.Now; var daysPart = (datetimeNow - new DateTime(2000, 1, 1)).Days; var secondsPart = (long)datetimeNow.TimeOfDay.TotalSeconds/2; var assemblyInfo = new AssemblyInfoSettings { Version = "3.0.0.0", FileVersion = string.Format("3.0.{0}.{1}", daysPart, secondsPart) }; CreateAssemblyInfo("MyProject/Properties/AssemblyInfo.cs", assemblyInfo); }); 

Aquí:

  • Versión: es la versión de ensamblaje. La mejor práctica es bloquear el número de versión principal y dejar el rest con ceros (como "1.0.0.0").
  • FileVersion: es la versión del file de ensamblaje.

Tenga en count que puede parchar no solo las versiones sino también toda la demás información necesaria .

Utilice la tarea AssemblyInfo del proyecto MSBuild Community Tasks ( http://msbuildtasks.tigris.org/ ) e instálela en su file .csproj / .vbproj.

Tiene una serie de opciones, incluida una para vincular el número de versión a la date y hora del día.

Recomendado.

A partir de ahora, para mi aplicación,

 string ver = Application.ProductVersion; 

devuelve ver = 1.0.3251.27860

El valor 3251 es el número de días desde 1/1/2000. Lo uso para poner una date de creación de versión en la pantalla de inicio de mi aplicación. Cuando trato con un usuario, puedo pedir la date de creación, que es más fácil de comunicar que un número largo.

(Soy un departamento de una persona que apoya a una empresa pequeña. Este enfoque puede no funcionar para usted).

El cambio de AssemblyInfo funciona en VS2012. Parece extraño que no haya más soporte para esto en Visual Studio, uno pensaría que esta era una parte básica del process de compilation / lanzamiento.

Cómo get la versión {major}.{year}.1{date}.1{time}

Este es algo experimental, pero me gusta. Inspirado por Jeff Atwood @ CodingHorror ( enlace ).

El número de versión resultante se convierte en 1.2016.10709.11641 (que significa 2016-07-09 16:41), lo que permite

  • pobre mans padding cero (con el estúpido líder 1 s)
  • un DateTime local casi legible para humanos embedded en el número de versión
  • dejando la versión Major sola para cambios realmente importantes.

Agregue un nuevo elemento a su proyecto, select General -> Plantilla de text, CustomVersionNumber como CustomVersionNumber y (cuando corresponda) CustomVersionNumber comentario fuera de AssemblyVersion y AssemblyFileVersion en Properties/AssemblyInfo.cs .

Luego, al save este file o crear el proyecto, se regenerará un file .cs ubicado como un subelemento debajo del file .tt creado.

 <#@ template language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> // // This code was generated by a tool. Any changes made manually will be lost // the next time this code is regenerated. // using System.Reflection; <# var date = DateTime.Now; int major = 1; int minor = date.Year; int build = 10000 + int.Parse(date.ToString("MMdd")); int revision = 10000 + int.Parse(date.ToString("HHmm")); #> [assembly: AssemblyVersion("<#= $"{major}.{minor}.{build}.{revision}" #>")] [assembly: AssemblyFileVersion("<#= $"{major}.{minor}.{build}.{revision}" #>")] 

Tal vez, para esta tarea, puede usar un código como este:

  private bool IncreaseFileVersionBuild() { if (System.Diagnostics.Debugger.IsAttached) { try { var fi = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory).Parent.Parent.GetDirectories("Properties")[0].GetFiles("AssemblyInfo.cs")[0]; var ve = System.Diagnostics.FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location); string ol = ve.FileMajorPart.ToString() + "." + ve.FileMinorPart.ToString() + "." + ve.FileBuildPart.ToString() + "." + ve.FilePrivatePart.ToString(); string ne = ve.FileMajorPart.ToString() + "." + ve.FileMinorPart.ToString() + "." + (ve.FileBuildPart + 1).ToString() + "." + ve.FilePrivatePart.ToString(); System.IO.File.WriteAllText(fi.FullName, System.IO.File.ReadAllText(fi.FullName).Replace("[assembly: AssemblyFileVersion(\"" + ol + "\")]", "[assembly: AssemblyFileVersion(\"" + ne + "\")]")); return true; } catch { return false; } } return false; } 

y llámalo desde la carga de formulario.
Con este código puede actualizar cualquier parte de la información del file en AssemblyInfo.cs (pero debe usar la estructura de directorys "estándar").

AssemblyInfoUtil . Gratis. Fuente abierta.

Estoy utilizando este enfoque http://sofes.miximages.com/a/827209/3975786 colocando la plantilla T4 en una "Elementos de solución" y utilizándola con "Agregar como enlace" dentro de cada proyecto.

Tal vez sea demasiado tarde para responder aquí, pero espero que eso resuelva el agitado problema de alguien.

Una forma automática de cambiar la versión de ensamblaje de todos sus proyectos mediante el script de PowerShell. Este artículo resolverá muchos de tus problemas.

Cada vez que hago una construcción, se incrementa automáticamente el dígito less significativo.

No tengo idea de cómo actualizar a los demás, pero al less ya deberías ver eso …

He creado una aplicación para incrementar la versión del file automáticamente.

  1. Descargar aplicación
  2. agregue la siguiente línea para precomstackr la línea de command del evento

    C: \ temp \ IncrementFileVersion.exe $ (SolutionDir) \ Properties \ AssemblyInfo.cs

  3. Construye el proyecto

Para que sea sencillo, la aplicación solo arroja posts si hay un error, para confirmar que funcionó bien necesitarás verificar la versión del file en 'Información de la Asamblea'

Nota: Deberá volver a cargar la solución en Visual Studio para get el button 'Información de ensamblaje' para rellenar los campos; sin embargo, su file de salida tendrá la versión actualizada.

Para sugerencias y requestes, envíeme un correo electrónico a telson_alva@yahoo.com

En .NET, la información de versión para un ensamblaje sigue el siguiente formatting: [ . . . ]

Este formatting de versión consta de cuatro valores:

 Major Version Minor Version Build Number Revision 

El valor superior a cuatro se puede usar para indicar diferentes cosas dependiendo de cómo desee que se entiendan.

Cuando comstackmos o construimos nuestro código en .NET (usando Visual Studio), se generan ensamblajes y este ensamblaje se puede labelr con tres types diferentes de versiones, que son las siguientes:

 Assembly Version Assembly File Version Assembly Informational Version 

Ahora tomemos un minuto para entender qué son estos y cómo o en qué context se utilizan.

Pruebe esta solución con video haga clic aquí