Puedo incrementar automáticamente el archivo de versión de compilación cuando se utiliza Visual Studio?

https://stackoverflow.com/questions/356543

21-08-2019
|

Pregunta

Me preguntaba cómo podía automáticamente incremento de la construcción (versión?) de mis archivos utilizando Visual Studio (2005).

Si miro las propiedades de decir C:\Windows\notepad.exe, la ficha Versión da "versión del Archivo:5.1.2600.2180".Me gustaría conseguir estos fabulosos números en la versión de la dll demasiado, no la versión 1.0.0.0, que deja la cara es un poco aburrido.

He intentado un par de cosas, pero no parece estar fuera-de-la funcionalidad del cuadro, o tal vez sólo estoy mirando en el lugar equivocado (como de costumbre).

Yo trabajo principalmente con proyectos web....

Miré a ambos:

y yo no podía creer lo mucho esfuerzo para hacer algo es una práctica estándar.

EDITAR:No funciona en VS2005 como mucho puedo decir (http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx)

Solución

En Visual Studio 2008, las siguientes obras.

Encuentra 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, el resultado final será con un producto Versión de 1.0. * y una versión del archivo de 1.0.0.0 . No es lo que quiere!

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

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

A continuación, el compilador se establece la versión del archivo para que sea igual a la versión del producto y obtendrá el resultado deseado de un producto y la versión de archivo de la subasta de forma automática que están en sincronía. P.ej. 1.0.3266.92689

Otros consejos

abrir el archivo AssemblyInfo.cs y cambiar

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

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

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

Sin embargo, esto sólo le permitirá al incremento automático de la versión de montaje y le dará la

Archivo Asamblea Versión: Un comodín ( "*") no está permitido en este campo

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

Así que abrir las AssemblyInfo.cs y hacerlo de forma manual.

Otra opción para cambiar los números de versión en cada generación es el uso de la Versión la tarea de MSBuild.De la comunidad.Tareas.Sólo tienes que descargar su instalador, instalar, luego adaptar el siguiente código y pegarlo después de <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> en su .csproj archivo:

<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 el StartDate de la propiedad para su configuración regional. Actualmente no uso el invariante de la cultura.

Para el tercer construir en enero 14, 2010, de esta forma se crea un VersionInfo.cs con este contenido:

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

Este archivo tiene que ser añadido para el proyecto (a través de Agregar elemento existente), y el AssemblyVersion y AssemblyFileVersion las líneas tienen que ser retirados de AssemblyInfo.cs.

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

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

estoy generando código y compilar a una Asamblea y quiero números de versión de incremento automático. Sin embargo, no puedo utilizar el VS 6.0. * AssemblyVersion truco como se auto-incrementos construyen números cada día y se rompe la compatibilidad con los conjuntos que utilizan un número de versión mayor. En su lugar, yo quiero tener un AssemblyVersion codificado, sino un AssemblyFileVersion incremento automático. Que he logrado esto especificando AssemblyVersion en los AssemblyInfo.cs y generar 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 creación. Debe incluir este archivo en el proyecto y construir con él.

Instalar el Construir Versión Incremento complemento. Se le da forma en un mayor control de la opción *.

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 lateral, 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 total de segundos en el día. Así que si se compila a medianoche debe ser cero.

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

Disparos pantalla

El establecimiento de un * en el número de versión en AssemblyInfo o en las propiedades del proyecto como se describe en los otros mensajes no funciona con todas las versiones de Visual Studio / .NET.

Que yo sepa no funcionó en VS 2005 (pero en VS 2003 y VS 2008). Para VS 2005, usted podría utilizar el siguiente: incremento automático Visual Studio 2005 versión de compilación y revisión número de compilación tiempo.

Pero tenga en cuenta que al cambiar el número de versión automática no se recomienda para los ensamblados con nombre. La razón es que todas las referencias a un conjunto de este tipo deben ser actualizados cada vez que el ensamblaje de referencia se reconstruyó debido al hecho de que las referencias ensamblado con nombre son siempre una referencia a una versión específica de montaje. Microsoft sí cambia el número de versión de los ensamblados de .NET Framework sólo si hay cambios en las interfaces. (NB:. Todavía estoy buscando el enlace en MSDN donde leí que)

Para conseguir incrementar la información (Fecha y hora) en la propiedad AssemblyFileVersion que tiene la ventaja de no romper las dependencias.

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 para leer los valores de nuevo. 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

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

Se puede hacer que sea más inteligente, por ejemplo, si sólo se actualice el archivo VersionInfo.cs cada pocos minutos / hora (mediante el uso de un archivo temporal y luego copiar / sobrescribir los VersionInfo.cs reales si se detecta un cambio bastante grande). Lo hice una vez bastante éxito.

Establecer el número de versión "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)

Es en las propiedades del proyecto en publicar

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

Cake soporta archivos AssemblyInfo parches. Con pastel en las manos tiene infinitas maneras de implementar la versión incremento automático.

Ejemplo simple de incrementar la versión como C # compilador:

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);
});

A continuación:

Versión - es la versión de montaje. La mejor práctica es bloquear número de versión principal y dejar que queda con ceros (como "1.0.0.0").
FileVersion - es la versión del archivo de montaje

Tenga en cuenta que puede parchear no sólo versiones, pero href="http://cakebuild.net/api/cake.common.solution.project.properties/8f09cb16" también toda otra información necesaria .

Ir al proyecto | Propiedades y luego en información de ensamblado y luego Versión Asamblea y poner un * en el último o el penúltimo cuadro (no se puede autoincrementación la Mayor o componentes de menor importancia).

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

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

Recomendado.

A partir de ahora, para mi aplicación,

string ver = Application.ProductVersion;

retornos ver = 1.0.3251.27860

El valor 3251 es el número de días desde el 1/1/2000. Yo lo uso para poner una fecha de creación de versión en la pantalla de presentación de mi solicitud. Cuando se trata de un usuario, puedo pedir a la fecha de creación, que es más fácil comunicarse a un número mucho tiempo.

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

Cambio de la AssemblyInfo funciona en VS2012. Parece extraño que no hay más apoyo para esto en Visual Studio, se podría pensar que esto era una parte fundamental del proceso de construcción / lanzamiento.

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

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

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

buenos mans cero de relleno (con el estúpido líder 1s)
casi humanos legible local DateTime incrustado en el número de versión
dejando de la versión Principal, solo para los muy importantes cambios recientes.

Agregar un nuevo elemento al proyecto, seleccione General> Plantilla de Texto, el nombre de algo como CustomVersionNumber y (donde sea aplicable) comentario el AssemblyVersion y AssemblyFileVersion en Properties/AssemblyInfo.cs.

Luego, al guardar el archivo, o la construcción del proyecto, esto va a generar un .cs archivo ubicado como un sub-elemento creado en virtud de la .tt archivo.

<#@ 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 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 se puede actualizar cualquier parte de información de archivo en AssemblyInfo.cs (pero debe utilizar la estructura de directorios "estándar").

AssemblyInfoUtil . Gratis. De código abierto.

Estoy usando este enfoque https://stackoverflow.com/a/827209/3975786 mediante la colocación de la T4 plantilla en una "Elementos de la solución" y usarlo con "Agregar Enlace" dentro de cada proyecto.

Tal vez sea demasiado tarde para contestar aquí, pero la esperanza de que va a resolver un problema agitada de alguien.

Un forma automática de cambiar la versión de montaje de todos sus proyectos utilizando script de PowerShell. En este artículo se resolver muchos de sus problemas.

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

He creado una aplicación para incrementar la versión del archivo de forma automática.

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

C: \ temp \ IncrementFileVersion.exe $ (SolutionDir) \ Propiedades \ AssemblyInfo.cs
Construir el proyecto

Para mantener la sencillez de la aplicación sólo lanza mensajes si hay un error, para confirmar que funcionaba bien tendrá que comprobar la versión del archivo en 'Información de ensamblado'

Nota:. Tendrá que volver a cargar la solución en Visual Studio para el botón 'Información de ensamblado' 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

En Visual Studio 2019

No fue suficiente para mí añadiendo

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

Cuando la construcción se me lanza este error

La cadena versión especificada no se ajusta al formato requerido

Solución

El formato fue finalmente aceptado después me puse a Deterministic False en project.csproj

<Deterministic>false</Deterministic>

Edit:

Por alguna razón entorno autoincrement_version.ps1 a AssemblyInfo.cs perdió mi archivo de configuración de cargarlo y guardarlo en diferentes ubicaciones.

Solución:

I fijó un evento posterior a la generación para incrementar el número de revisión:

secuencia de comandos posterior a la generación de lotes de eventos

Esto llama a un script de PowerShell llamado <=> pasando como argumento el camino de <=>

if $(ConfigurationName) == Release (
PowerShell -ExecutionPolicy RemoteSigned $(ProjectDir)autoincrement_version.ps1 '$(ProjectDir)My Project\AssemblyInfo.cs'
)

PoweShell guión

autoincrements el número de revisión usando Regex

param( [string]$file );
  $regex_revision = '(?<=Version\("(?:\d+\.)+)(\d+)(?="\))'
  $found = (Get-Content $file) | Select-String -Pattern $regex_revision
  $revision = $found.matches[0].value
  $new_revision = [int]$revision + 1
  (Get-Content $file) -replace $regex_revision, $new_revision | Set-Content $file -Encoding UTF8

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow

Puedo incrementar automáticamente el archivo de versión de compilación cuando se utiliza Visual Studio?

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

En Visual Studio 2019

Solución

Edit:

Solución:

secuencia de comandos posterior a la generación de lotes de eventos

PoweShell guión

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