c# - ¿Puedo incrementar automáticamente la versión de compilación de archivos cuando uso Visual Studio?

asp.net visual-studio

Question

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

Si busco las propiedades de, por ejemplo, C:/Windows/notepad.exe , la pestaña Versión muestra "Versión del archivo: 5.1.2600.2180". Me gustaría obtener estos números geniales en la versión de mis archivos DLL también, no en la versión 1.0.0.0, lo que, en definitiva, es un poco aburrido.

Intenté algunas cosas, pero no parece ser una funcionalidad fuera de la caja, 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 para hacer algo es una práctica estándar.

EDIT: No funciona en VS2005 por lo que puedo decir ( http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx )

Answer 1

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

Este es un tanto experimental, pero me gusta. Inspirado por Jeff Atwood @ CodingHorror ( link ).

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

• pobre hombre cero relleno (con el estúpido líder 1 s)
• DateTime local legible casi por humanos incrustado en el número de versión
• dejando la versión Major solo para cambios realmente importantes.

Agregue un nuevo elemento a su proyecto, seleccione General -> Plantilla de texto, CustomVersionNumber nombre como CustomVersionNumber y (cuando corresponda) comente sobre AssemblyVersion y AssemblyFileVersion en Properties/AssemblyInfo.cs .

Luego, cuando guarde este archivo, o genere el proyecto, esto generará 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 2

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 el 1/1/2000. Lo uso para poner una fecha de creación de la 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.

(Soy un departamento de un solo hombre que brinda apoyo a una pequeña empresa. Es posible que este enfoque no funcione para usted).

Answer 3

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

No tengo idea de cómo actualizar los otros, pero al menos ya deberías estar viendo eso ...

Answer 4

Cambiando los trabajos de AssemblyInfo en VS2012. Parece extraño que no haya más soporte para esto en Visual Studio, pensarías que esto era una parte básica del proceso de compilación / lanzamiento.

Answer 5

En Visual Studio 2008, los siguientes trabajos.

Encuentre el archivo 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 del producto de 1.0. * Y una versión del archivo de 1.0.0.0 . No es lo que quieres!

Sin embargo, si eliminas la segunda de estas líneas y solo tienes:

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

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

Answer 6

Está en las propiedades de su proyecto en Publicar

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

Answer 7

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

Answer 8

Estoy usando este enfoque https://.com/a/827209/3975786 al colocar la plantilla T4 en "Elementos de solución" y usarla con "Agregar como enlace" dentro de cada proyecto.

Answer 9

Hay una extensión de Visual Studio con versiones automáticas que admite Visual Studio 2012, 2013, 2015 y 2017.

Capturas de pantalla

Answer 10

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

1. Descargar Application

2. agregue la siguiente línea a la línea de comando de evento de precompilación

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

3. Construir el proyecto

Para mantenerlo simple, la aplicación solo muestra mensajes si hay un error, para confirmar que funcionó bien, deberá verificar la versión del archivo en ''Información de ensamblaje''

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

Para sugerencias y solicitudes, por favor envíeme un correo electrónico a [email protected]

Answer 11

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

Answer 12

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

Answer 13

La configuración de un * en el número de versión en AssemblyInfo o en las propiedades 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 (sino en VS 2003 y VS 2008). Para VS 2005, puede usar lo siguiente: http://www.codeproject.com/KB/dotnet/Auto_Increment_Version.aspx .

Pero tenga en cuenta que no se recomienda cambiar el número de versión automáticamente para ensamblajes con nombre seguro. La razón es que todas las referencias a dicho ensamblaje deben actualizarse cada vez que se reconstruye el ensamblaje al que se hace referencia debido al hecho de que las referencias de ensamblaje con nombre seguro son siempre 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 14

Otra opción para cambiar los números de versión en cada compilación es usar la tarea de 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 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: Adapte la propiedad StartDate a su localidad. Actualmente no utiliza la cultura invariante.

Para la tercera compilación el 14 de enero de 2010, esto crea una VersionInfo.cs con este contenido:

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

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

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

Answer 15

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 me funcionó, quizás debido a VS2008?), Puede usar una combinación de un evento de construcción previa que genere un archivo, agregue ese archivo (incluidas sus propiedades de versión) y luego use 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 archivo VersionInfo.cs resultante (subcarpeta de propiedades) en su proyecto

Código para recuperar la fecha (años 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 crea muchas reconstrucciones forzadas (ya que un archivo 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 el VersionInfo.cs real si se detecta un cambio lo suficientemente grande). Lo hice una vez con bastante éxito.

Answer 16

Para obtener los números 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 total de segundos en el día. Así que si compilas a medianoche debería ser cero.

Answer 17

Se me ocurrió una solución similar a la de 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 un código y compilando para un ensamblaje y quiero auto-incrementar los números de versión. Sin embargo, no puedo usar el truco VSV. * AssemblyVersion, ya que incrementa automáticamente los números de compilación cada día y rompe la compatibilidad con los Ensamblajes que usan un número de compilación anterior. En su lugar, quiero tener una AssemblyVersion codificada, pero una AssemblyFileVersion auto-incrementable. 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 archivo VersionInfo.cs con un atributo Assembly 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 construirlo con él.

Answer 18

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

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

Answer 19

Tal vez, para esta tarea, puedes usar 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 llamarlo desde la carga de formularios.
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 20

Use la tarea AssemblyInfo del proyecto de tareas de la comunidad de MSBuild ( http://msbuildtasks.tigris.org/ ) e intégrelo 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 21

abre el archivo AssemblyInfo.cs y cambia

// 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")]

puede hacer esto en IDE yendo al proyecto -> propiedades -> información de ensamblaje

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

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

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

Así que simplemente abre el assemblyinfo.cs y hazlo manualmente.

Answer 22

Cake soporta parches de archivos AssemblyInfo. Con la torta en las manos, tiene infinitas formas de implementar incrementos automáticos de versiones.

Un simple ejemplo de versión incremental como el 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 los ceros restantes (como "1.0.0.0").
• FileVersion - es la versión del archivo de ensamblaje.

Tenga en cuenta que puede parchear no solo las versiones, sino también toda la información necesaria .

Answer 23

AssemblyInfoUtil . Gratis. Fuente abierta.