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

Si busco las propiedades de say C:\Windows\notepad.exe, la pestaña Versión muestra "Versión del archivo: 5.1.2600.2180". También me gustaría obtener estos números geniales en la versión de mi dll, no en la versión 1.0.0.0, lo que seamos un poco aburridos.

Intenté algunas cosas, pero no parece ser una funcionalidad lista para usar, o tal vez solo 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 sea una práctica estándar.

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

En Visual Studio 2008, los siguientes trabajos.

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

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

Podrías 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 elimina la segunda de estas líneas y solo tiene:

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

Luego, el compilador establecerá que la Versión del archivo sea igual a la Versión del producto y obtendrá el resultado deseado de un producto que se incrementa automáticamente y la versión del archivo que están sincronizados. Ej. 1.0.3266.92689

abra el archivo 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")]

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á el

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

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

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

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 . Simplemente descargue su instalador, instálelo, luego adapte el siguiente código y péguelo después <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />en su .csprojarchivo:

<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 entorno local. Actualmente no utiliza la cultura invariante.

Para la tercera compilación el 14 de enero de 2010, esto crea un VersionInfo.cscon 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 AssemblyVersiony AssemblyFileVersiondeben eliminarse AssemblyInfo.cs.

Los diferentes algoritmos para el cambio de los componentes de la versión se describen en $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chmy propiedades de versión .

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 código y compilando a un ensamblado y quiero incrementar automáticamente los números de versión. Sin embargo, no puedo usar el truco VS 6.0. * AssemblyVersion ya que incrementa automáticamente los números de compilación cada día y rompe la compatibilidad con los ensamblados que usan un número de compilación anterior. En cambio, quiero tener una versión de ensamblaje codificada pero una versión de ensamblaje de incremento automático. He logrado esto 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 construir con él.

Instale el complemento Incremento de versión de compilación . Te da mucho más control que la opción *.

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. Entonces, si compila a medianoche, debería ser cero.

Hay una extensión de Visual Studio Automatic Versions que admite Visual Studio (2012, 2013, 2015) 2017 y 2019.

Capturas de pantalla

Establecer 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: Incremento automático Versión de versión de Visual Studio 2005 y número de revisión en tiempo de compilación .

Pero tenga en cuenta que no se recomienda cambiar el número de versión automáticamente para los ensamblados con nombre seguro. La razón 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 ensamblaje con nombre seguro 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. (Nota: todavía estoy buscando el enlace en MSDN donde lo leí).

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

Basándose en la solución de Boog (¿no funcionó para mí, tal vez debido a VS2008?), Puede usar una combinación de un evento previo a la compilación que genera un archivo, agrega ese archivo (incluidas sus propiedades de versión) y luego usa una forma de leer esos valores de nuevo. Es decir..

Evento previo a la compilación:

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 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 es muy cómodo ... además, 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 (mediante el uso de un archivo temporal y luego copiando / sobrescribiendo el VersionInfo.cs real si se detecta un cambio lo suficientemente grande). Hice esto una vez con bastante éxito.

Establezca el número de versión en "1.0. *" Y completará 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)

Está en las propiedades de su proyecto en Publicar

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

Cake admite el parcheado de archivos AssemblyInfo. Con el pastel en las manos, tiene infinitas formas de implementar el incremento automático de versiones.

Ejemplo simple de versión incremental como lo hace el compilador de C #:

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 resto con ceros (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 otra información necesaria .

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

Use la tarea AssemblyInfo del proyecto MSBuild Community Tasks ( http://msbuildtasks.tigris.org/ ) e integrela en su archivo .csproj / .vbproj.

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

Recomendado.

A partir de ahora, para mi aplicación,

string ver = Application.ProductVersion;

devoluciones ver = 1.0.3251.27860

El valor 3251 es el número de días desde 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 preguntarle 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 apoya una pequeña empresa. Este enfoque puede no funcionar para usted).

Cambiar la información de ensamblaje funciona en VS2012. Parece extraño que no haya más soporte para esto en Visual Studio, pensarías que esto fue una parte básica del proceso de compilació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 ).

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

• pobre mans cero relleno (con los estúpidos iniciales 1)
• DateTime local casi legible por humanos incrustado en el número de versión
• dejando solo la versión Major para cambios realmente importantes.

Agregue un nuevo elemento a su proyecto, seleccione General -> Plantilla de texto, asígnele un nombre similar CustomVersionNumbery (cuando corresponda) comente el AssemblyVersiony AssemblyFileVersiondentro Properties/AssemblyInfo.cs.

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

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

1. Descargar aplicación

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. Construye el proyecto

Para simplificar, la aplicación solo envía mensajes 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 llenar los campos, sin embargo, su archivo de salida tendrá la versión actualizada.

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

En Visual Studio 2019

No fue suficiente para mí agregar

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

Al construirlo me arroja este error

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

Solución

El formato fue finalmente aceptada después de la configuración I Deterministica Falseenproject.csproj

<Deterministic>false</Deterministic>

Editar:

Por alguna razón ajuste Deterministica Falseperdió mi archivo de configuración de cargarlo y guardarlo en diferentes lugares.

Solución alterna:

Configuré un evento posterior a la compilación para incrementar el número de revisión:

Script por lotes de eventos posteriores a la compilación

Esto llama a un script de PowerShell llamado autoincrement_version.ps1pasar como argumento la ruta de acceso deAssemblyInfo.cs

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

Script Poweshell

Incrementa automáticamente 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

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 llamarlo desde la carga del formulario.
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").

AssemblyInfoUtil . Gratis. Fuente abierta.

Estoy usando este enfoque https://stackoverflow.com/a/827209/3975786 colocando la plantilla T4 en "Elementos de solución" y usá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 compilación, incrementa automáticamente el dígito menos significativo.

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

Para cualquiera que use Tortoise Subversion, puede vincular uno de sus números de versión al número de Revisión de subversión de su código fuente. Esto me parece muy útil (¡a los auditores también les gusta esto!). Para ello, llame a la utilidad WCREV en su compilación previa y genere su AssemblyInfo.cs a partir de una plantilla.

Si su plantilla se llama AssemblyInfo.wcrev y se encuentra en el directorio AssemblyInfo.cs normal, y la tortuga está en el directorio de instalación predeterminado, entonces su comando Pre-Build se ve así (Nota: Todo en una línea):

"C:\Program Files\TortoiseSVN\bin\SubWCRev.exe" "$(ProjectDir)." "$(ProjectDir)Properties\AssemblyInfo.wcrev"  "$(ProjectDir)Properties\AssemblyInfo.cs"

El archivo de plantilla incluiría la cadena de sustitución de token wcrev: $ WCREV $
eg

[assembly: AssemblyFileVersion("1.0.0.$WCREV$")]

Nota:
Como ahora se genera su AssemblyInfo.cs, no desea que se controle su versión.