¿Puedo aumentar automáticamente la versión de compilación del archivo cuando uso Visual Studio?

Question

Me preguntaba cómo podría automáticamente aumentar la compilación (y la versión?) De mis archivos con Visual Studio (2005).

Si busco las propiedades de decir C:\Windows\notepad.exe, la pestaña Versión da "Versión del archivo: 5.1.2600.2180". Me gustaría obtener estos números 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 la funcionalidad lista para usar, o tal vez estoy buscando en el lugar equivocado (como de costumbre).

Yo 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 yo no podía creer que tanto esfuerzo hacer algo es una práctica estándar.

EDIT: no funciona en VS2005 en la medida que puedo decir (http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx)

Answer 1

En visual Studio 2008, funciona lo siguiente.

Encuentre el archivo AssemblyInfo.cs y encontrar estas 2 líneas:

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

usted podría intentar cambiar esto:

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

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

Sin embargo, si se quita la segunda de estas líneas y apenas tiene:

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

A continuación, el compilador fijará la versión del archivo para que sea igual a la versión del producto y obtendrá el resultado deseado de una forma automática incrementar el producto y la versión del archivo que están sincronizados. P.ej. 1.0.3266.92689

Answer 2

Cada vez que hago una acumulación se auto-incrementa el dígito menos significativo.

no tengo ni idea de cómo actualizar los demás, pero al menos debe estar viendo que ya ...

Answer 3

Ir al 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 aumentar automáticamente los componentes Mayor o Menor).

Answer 4

para obtener los números de versión tratan

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, crear/editar AssemblyInfo.cs

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

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

Answer 5

abra AssemblyInfo.archivo de 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")] 

se puede hacer esto en el IDE, vaya a proyectar -> propiedades -> información de ensamblado

Sin embargo, esto sólo le permitirá al incremento automático del Versión de ensamblaje y le dará el

Versión de archivo de ensamblaje: Un comodín ("*") no está permitido en este campo

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

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

Answer 6

Ajuste el número de versión de "1.0. *" Y se completará automáticamente los dos últimos números de la fecha (en días desde algún punto) y el tiempo (la mitad de los segundos desde la medianoche)

Answer 7

Es en las propiedades del proyecto bajo Publicar

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

Answer 8

el establecimiento de un * en el número de versión en AssemblyInfo o bajo Pro ject properties 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 puede usar lo siguiente: Auto Increment Visual Studio 2005 version build and revision number on compile time.

Pero tenga en cuenta que no se recomienda cambiar el número de versión automáticamente para ensamblajes de nombre seguro. El motivo es que todas las referencias a dicho ensamblaje deben actualizarse cada vez que se reconstruye el ensamblado al que se hace referencia debido al hecho de que las referencias de ensamblado de nombre fuerte siempre son una referencia 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. (NB: Todavía estoy buscando el enlace en MSDN donde lo leí).

Answer 9

A partir de ahora, para mi aplicación,

string ver = Application.ProductVersion; 

vuelve ver = 1.0.3251.27860

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

(yo soy un departamento de un solo hombre el apoyo a una pequeña empresa. Este enfoque puede no funcionar para usted.)

Answer 10

Utilice la tarea AssemblyInfo de las tareas de MSBuild Comunidad proyecto (http://msbuildtasks.tigris.org/), e integrarlo en su archivo .csproj/.vbproj.

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

Recomendado.

Answer 11

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

Answer 12

Otra opción para cambiar los números de versión en cada compilación es usar la tarea Versión de MSBuild.Community.Tasks. Sólo tiene que descargar su instalador, instalarlo, entonces adaptar el siguiente código y pegarlo después <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> en su archivo .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: Adaptar la propiedad StartDate a su localidad. It currently does not use the invariant culture.

Por tercer construir el 14 de enero de 2010, esto crea un VersionInfo.cs con este contenido:

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

Este archivo tiene que ser añadido al proyecto (a través de Agregar elemento existente), y las líneas AssemblyVersion y AssemblyFileVersion deben eliminarse del AssemblyInfo.cs.

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

Answer 13

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 compilando en un Ensamblaje y quiero incrementar automáticamente los números de versión. Sin embargo, no puedo usar el VS 6.0.* Truco de AssemblyVersion a medida que incrementa automáticamente los números de compilación y rompe la compatibilidad con los ensambles que usan un número de compilación más antiguo. En cambio, quiero tener una AssemblyVersion codificada pero una AssemblyFileVersion de incremento automático. He logrado esto especificando AssemblyVersion en los AssemblyInfo.cs y generando una 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 archivo con un atributo VersionInfo.cs Asamblea para AssemblyFileVersion donde la versión sigue el esquema de YY.MM.DD.TTTT con la fecha de compilación. Debe incluir este archivo en su proyecto y compilar con él.

Answer 14

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

---

Sobre la base de la solución de Boog (no funcionó para mí, tal vez debido a VS2008?), Se puede utilizar una combinación de un evento de pre-construcción generar un archivo, añadiendo que el archivo (incluyendo sus propiedades de versión) y luego usando una forma de leer esos valores nuevamente. Es decir ..

Pre-Construcción-Evento:

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 

Incluir el archivo VersionInfo.cs resultante (Propiedades subcarpeta) en su proyecto

Código para obtener la fecha de nuevo (año hasta 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 es muy cómodo .. también, no sé si se crea una gran cantidad de fuerza-reconstruye (ya que los archivos siempre cambia).

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

Answer 15

Tal vez, para esta tarea, puede utilizar código como el siguiente:

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 lo llaman de la forma de carga.
Con este código puede actualizar cualquier parte de la información del archivo en AssemblyInfo.cs (pero debe usar la estructura de directorios "estándar").

Answer 16

Cambiando 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 proceso de compilación/lanzamiento.

Answer 17

AssemblyInfoUtil. Gratis. Fuente abierta.

Answer 18

Estoy usando este enfoque https://stackoverflow.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.

Answer 19

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

ejemplo simple de incrementar versiones como compilador de 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 montaje. La mejor práctica es bloquear el número de versión principal y dejar el resto con ceros (como "1.0.0.0").
• FileVersion - es la versión del archivo de ensamblaje.

Tenga en cuenta que puede parchar no solo las versiones sino also all other necessary information.

Answer 20

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

Ésta es una especie de experimentación, pero me gusta. Inspirado por Jeff Atwood @ CodingHorror (link).

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

• Mans pobres cero relleno (con los estúpidos principales 1 s)
• legible casi-humana local DateTime incrustado en el número de versión
• dejando la versión principal solo para cambios realmente importantes.

añadir un nuevo elemento a su proyecto, seleccione General -> Plantilla de texto, el nombre es algo así como CustomVersionNumber y (en su caso) comente la AssemblyVersion y AssemblyFileVersion en Properties/AssemblyInfo.cs.

Luego, al guardar este archivo o crear el proyecto, se regenerará un archivo .cs ubicado como un subelemento debajo del archivo .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}" #>")] 

Answer 21

Quizás sea demasiado tarde para responder aquí, pero espero que eso solucione el problema agitado de alguien.

Una forma automática de para cambiar la versión de ensamblaje de todos sus proyectos mediante el script de PowerShell. This article resolverá muchos de sus problemas.

Answer 22

Hay una extensión de Visual Studio Automatic Versions que soporta Visual Studio 2012, 2013, 2015 & 2017.

Pantallas

Answer 23

He creado una aplicación para incrementar el versión del archivo automáticamente

1. Descargar Application

2. añadir la siguiente línea de pre-construcción de línea de comandos del evento

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

3. Cree el proyecto

Para que sea sencillo, la aplicación solo lanza mensajes i Si hay un error, para confirmar que funcionó bien, deberá verificar la versión del archivo en 'Información de ensamblaje'

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

Para sugerencias y peticiones por favor un correo electrónico a telson_alva@yahoo.com

Answer 24

En .NET, información de versión de un ensamblado sigue siguiente formato - [.. .].

Este formato de la versión consta de cuatro valores:

Major Version 
Minor Version 
Build Number 
Revision 

por encima de cuatro valor se puede utilizar para indicar cosas distintas dependiendo de cómo se desea que sean entendidas.

Cuando compilamos o construimos nuestro código en .NET (utilizando Visual Studio), que da salida a las asambleas y este montaje se puede etiquetar con tres diferentes tipos de versiones, que son los siguientes:

Assembly Version 
Assembly File Version 
Assembly Informational Version 

Ahora vamos tómese un minuto para comprender qué son estos y cómo o en qué contexto se utilizan.

tarjeta

Try this solution with video click here