¿Cómo tener un número de versión de incremento automático (Visual Studio)?

Quiero almacenar un conjunto de enteros que aumenten automáticamente al momento de la comstackción:

int MajorVersion = 0; int MinorVersion = 1; int Revision = 92; 

Cuando compilo, se autoincrementaría la Revision . Cuando construyo el proyecto de instalación, se incrementaría MinorVersion (estoy de acuerdo con hacerlo manualmente). MajorVersion solo se incrementaría manualmente.

Entonces podría mostrar un número de versión en el menú Ayuda / Acerca de al usuario como:

   Versión: 0.1.92

¿Cómo se puede lograr esto?

Esta pregunta no solo le pregunta cómo tener un número de versión de incremento automático, sino también cómo usarlo en el código, que es una respuesta más completa que otras.

Si agrega una clase AssemblyInfo a su proyecto y modifica el atributo AssemblyVersion para que finalice con un asterisco, por ejemplo:

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

Visual Studio boostá el número final para usted de acuerdo con estas reglas (gracias galets, ¡lo tuve completamente equivocado!)

Para hacer referencia a esta versión en código, para que pueda mostrarla al usuario, use la reflexión. Por ejemplo,

 Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version; DateTime buildDate = new DateTime(2000, 1, 1) .AddDays(version.Build).AddSeconds(version.Revision * 2); string displayableVersion = $"{version} ({buildDate})"; 

Dos capturas importantes que debes saber

Desde @ ashes999:

También vale la pena señalar que si se especifican tanto AssemblyVersion como AssemblyFileVersion , no verá esto en su .exe.

De @ BrainSlugs83:

Configurar solo el 4to número para ser * puede ser malo, ya que la versión no siempre se incrementará. El tercer número es el número de días desde el año 2000, y el cuarto número es el número de segundos desde la medianoche (dividido por 2) [NO ES ALEATORIO]. Entonces, si construyes la solución tarde en un día un día, y temprano en un día al día siguiente, la comstackción posterior tendrá un número de versión anterior. Recomiendo usar siempre XY* lugar de XYZ* porque su número de versión SIEMPRE boostá de esta manera.

Puede usar el mecanismo de plantillas T4 en Visual Studio para generar el código fuente requerido a partir de un archivo de texto simple :

Quería configurar la generación de información de versión para algunos proyectos .NET. Ha pasado mucho tiempo desde que investigué las opciones disponibles, así que busqué con la esperanza de encontrar una forma simple de hacerlo. Lo que he encontrado no parece muy alentador: las personas escriben complementos de Visual Studio y tareas personalizadas de MsBuild solo para obtener un número entero (vale, tal vez dos). Esto se sintió excesivo para un pequeño proyecto personal.

La inspiración provino de una de las discusiones de StackOverflow donde alguien sugirió que las plantillas T4 podrían hacer el trabajo. Y por supuesto que pueden. La solución requiere un mínimo esfuerzo y no requiere personalización de Visual Studio o del proceso de comstackción. Aquí lo que se debe hacer:

  1. Cree un archivo con la extensión “.tt” y coloque allí la plantilla T4 que generará los atributos AssemblyVersion y AssemblyFileVersion:
 <#@ template language="C#" #> // // This code was generated by a tool. Any changes made manually will be lost // the next time this code is regenerated. // using System.Reflection; [assembly: AssemblyVersion("1.0.1.<#= this.RevisionNumber #>")] [assembly: AssemblyFileVersion("1.0.1.<#= this.RevisionNumber #>")] <#+ int RevisionNumber = (int)(DateTime.UtcNow - new DateTime(2010,1,1)).TotalDays; #> 

Deberá decidir sobre el algoritmo de generación del número de versión. Para mí fue suficiente generar automáticamente un número de revisión establecido en el número de días desde el 1 de enero de 2010. Como puede ver, la regla de generación de la versión está escrita en C # simple, por lo que puede ajustarla fácilmente a sus necesidades .

  1. El archivo anterior debe colocarse en uno de los proyectos. Creé un nuevo proyecto con solo este archivo para hacer que la técnica de administración de versiones sea clara. Cuando construyo este proyecto (en realidad ni siquiera necesito construirlo: guardar el archivo es suficiente para activar una acción de Visual Studio), se genera el siguiente C #:
 // // This code was generated by a tool. Any changes made manually will be lost // the next time this code is regenerated. // using System.Reflection; [assembly: AssemblyVersion("1.0.1.113")] [assembly: AssemblyFileVersion("1.0.1.113")] 

Sí, hoy son 113 días desde el 1 de enero de 2010. Mañana cambiará el número de revisión.

  1. El siguiente paso es eliminar los atributos AssemblyVersion y AssemblyFileVersion de los archivos de AssemblyInfo.cs en todos los proyectos que deben compartir la misma información de versión generada automáticamente. En su lugar, elija “Agregar elemento existente” para cada proyecto, vaya a la carpeta con el archivo de plantilla T4, seleccione el archivo “.cs” correspondiente y agréguelo como un enlace. ¡Que hará!

Lo que me gusta de este enfoque es que es liviano (no hay tareas de MsBuild personalizadas) y la información de la versión generada automáticamente no se agrega al control de fuente. Y, por supuesto, al utilizar C # para el algoritmo de generación de versión se abren algoritmos de cualquier complejidad.

Esta es mi implementación de la sugerencia de T4 … Esto boostá el número de comstackción cada vez que construya el proyecto, independientemente de la configuración seleccionada (es decir, depuración | versión), y boostá el número de revisión cada vez que realice una comstackción de versión. Puede continuar actualizando los números de versión mayor y menor a través de la Aplicación ➤ Información de la Asamblea …

Para explicarlo con más detalle, leerá el archivo existente AssemblyInfo.cs y usará regex para encontrar la información de AssemblyVersion y luego incrementará la revisión y los números de comstackción en función de la entrada de TextTransform.exe .

  1. Elimine su archivo existente AssemblyInfo.cs .
  2. Cree un archivo AssemblyInfo.tt en su lugar. Visual Studio debe crear AssemblyInfo.cs y agruparlo con el archivo T4 después de guardar el archivo T4.

     <#@ template debug="true" hostspecific="true" language="C#" #> <#@ output extension=".cs" #> <#@ import namespace="System.IO" #> <#@ import namespace="System.Text.RegularExpressions" #> <# string output = File.ReadAllText(this.Host.ResolvePath("AssemblyInfo.cs")); Regex pattern = new Regex("AssemblyVersion\\(\"(?\\d+)\\.(?\\d+)\\.(?\\d+)\\.(?\\d+)\"\\)"); MatchCollection matches = pattern.Matches(output); if( matches.Count == 1 ) { major = Convert.ToInt32(matches[0].Groups["major"].Value); minor = Convert.ToInt32(matches[0].Groups["minor"].Value); build = Convert.ToInt32(matches[0].Groups["build"].Value) + 1; revision = Convert.ToInt32(matches[0].Groups["revision"].Value); if( this.Host.ResolveParameterValue("-","-","BuildConfiguration") == "Release" ) revision++; } #> using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Resources; // General Information [assembly: AssemblyTitle("Insert title here")] [assembly: AssemblyDescription("Insert description here")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("Insert company here")] [assembly: AssemblyProduct("Insert product here")] [assembly: AssemblyCopyright("Insert copyright here")] [assembly: AssemblyTrademark("Insert trademark here")] [assembly: AssemblyCulture("")] // Version informationr( [assembly: AssemblyVersion("<#= this.major #>.<#= this.minor #>.<#= this.revision #>.<#= this.build #>")] [assembly: AssemblyFileVersion("<#= this.major #>.<#= this.minor #>.<#= this.revision #>.<#= this.build #>")] [assembly: NeutralResourcesLanguageAttribute( "en-US" )] <#+ int major = 1; int minor = 0; int revision = 0; int build = 0; #> 
  3. Agregue esto a su evento de preconstrucción:

     "%CommonProgramFiles(x86)%\microsoft shared\TextTemplating\$(VisualStudioVersion)\TextTransform.exe" -a !!BuildConfiguration!$(Configuration) "$(ProjectDir)Properties\AssemblyInfo.tt" 

Si coloca un asterisco para comstackr y revisar Visual Studio usa la cantidad de días desde el 1 de enero de 2000 como número de comstackción y el número de segundos desde la medianoche dividido por 2 como la revisión.

Una solución MUCHO mejor salvavidas es http://autobuildversion.codeplex.com/

Funciona como un encanto y es MUY flexible.

Aquí está la cita en AssemblyInfo.cs de MSDN :

Puede especificar todos los valores o puede aceptar el número de comstackción predeterminado, el número de revisión o ambos utilizando un asterisco ( ). Por ejemplo, [assembly: AssemblyVersion (“2.3.25.1”)] indica 2 como versión principal, 3 como versión secundaria, 25 como número de comstackción y 1 como número de revisión. Un número de versión como [assembly: AssemblyVersion (“1.2. “)] Especifica 1 como la versión principal, 2 como versión secundaria y acepta los números de comstackción y revisión predeterminados. Un número de versión como [assembly: AssemblyVersion (“1.2.15. *”)] Especifica 1 como versión principal, 2 como versión secundaria, 15 como número de comstackción y acepta el número de revisión predeterminado. El número de comstackción predeterminado se incrementa diariamente. El número de revisión predeterminado es aleatorio

Esto efectivamente dice, si pones un 1.1. * En la información de ensamblaje, solo el número de comstackción se autoincrementará, y sucederá no después de cada comstackción, sino a diario. El número de revisión cambiará cada comstackción, pero de forma aleatoria, en lugar de hacerlo de manera creciente.

Esto es probablemente suficiente para la mayoría de los casos de uso. Si eso no es lo que está buscando, tiene que escribir una secuencia de comandos que se autoincrementará en la versión # en el paso previo a la comstackción.

Use AssemblyInfo.cs

Cree el archivo en App_Code: y complete lo siguiente o use Google para otras posibilidades de atributo / propiedad.

AssemblyInfo.cs

 using System.Reflection; [assembly: AssemblyDescription("Very useful stuff here.")] [assembly: AssemblyCompany("companyname")] [assembly: AssemblyCopyright("Copyright © me 2009")] [assembly: AssemblyProduct("NeatProduct")] [assembly: AssemblyVersion("1.1.*")] 

AssemblyVersion es la parte que realmente buscas.

Entonces, si está trabajando en un sitio web, en cualquier página aspx o control, puede agregar la etiqueta , la siguiente:

 CompilerOptions="\App_Code\AssemblyInfo.cs" 

(reemplazando la ruta de carpeta con la variable apropiada, por supuesto).

No creo que deba agregar opciones de comstackción de ninguna manera para otras clases; todos los que están en App_Code deben recibir la información de la versión cuando se comstackn.

Espero que ayude.

  • Estrella en la versión (como “2.10.3. *”) – es simple, pero los números son demasiado grandes

  • AutoBuildVersion: se ve muy bien, pero no funciona en mi VS2010.

  • El guión de @DrewChapin funciona, pero no puedo en mi estudio establecer modos diferentes para el evento de preconstrucción de depuración y lanzamiento del evento de preconstrucción.

así que cambié el script un poco … commamd:

 "%CommonProgramFiles(x86)%\microsoft shared\TextTemplating\10.0\TextTransform.exe" -a !!$(ConfigurationName)!1 "$(ProjectDir)Properties\AssemblyInfo.tt" 

y script (esto funciona con las configuraciones “Depurar” y “Liberar”):

 <#@ template debug="true" hostspecific="true" language="C#" #> <#@ output extension=".cs" #> <#@ assembly name="System.Windows.Forms" #> <#@ import namespace="System.IO" #> <#@ import namespace="System.Text.RegularExpressions" #> <# int incRevision = 1; int incBuild = 1; try { incRevision = Convert.ToInt32(this.Host.ResolveParameterValue("","","Debug"));} catch( Exception ) { incBuild=0; } try { incBuild = Convert.ToInt32(this.Host.ResolveParameterValue("","","Release")); } catch( Exception ) { incRevision=0; } try { string currentDirectory = Path.GetDirectoryName(Host.TemplateFile); string assemblyInfo = File.ReadAllText(Path.Combine(currentDirectory,"AssemblyInfo.cs")); Regex pattern = new Regex("AssemblyVersion\\(\"\\d+\\.\\d+\\.(?\\d+)\\.(?\\d+)\"\\)"); MatchCollection matches = pattern.Matches(assemblyInfo); revision = Convert.ToInt32(matches[0].Groups["revision"].Value) + incRevision; build = Convert.ToInt32(matches[0].Groups["build"].Value) + incBuild; } catch( Exception ) { } #> using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; // General Information about an assembly is controlled through the following // set of attributes. Change these attribute values to modify the information // associated with an assembly. [assembly: AssemblyTitle("Game engine. Keys: F2 (Debug trace), F4 (Fullscreen), Shift+Arrows (Move view). ")] [assembly: AssemblyProduct("Game engine")] [assembly: AssemblyDescription("My engine for game")] [assembly: AssemblyCompany("")] [assembly: AssemblyCopyright("Copyright © Name 2013")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] // Setting ComVisible to false makes the types in this assembly not visible // to COM components. If you need to access a type in this assembly from // COM, set the ComVisible attribute to true on that type. Only Windows // assemblies support COM. [assembly: ComVisible(false)] // On Windows, the following GUID is for the ID of the typelib if this // project is exposed to COM. On other platforms, it unique identifies the // title storage container when deploying this assembly to the device. [assembly: Guid("00000000-0000-0000-0000-000000000000")] // Version information for an assembly consists of the following four values: // // Major Version // Minor Version // Build Number // Revision // [assembly: AssemblyVersion("0.1.<#= this.revision #>.<#= this.build #>")] [assembly: AssemblyFileVersion("0.1.<#= this.revision #>.<#= this.build #>")] <#+ int revision = 0; int build = 0; #> 

Podría intentar usar UpdateVersion por Matt Griffith . Ya es bastante viejo, pero funciona bien. Para usarlo, simplemente necesita configurar un evento de preconstrucción que apunte a su archivo AssemblyInfo.cs, y la aplicación actualizará los números de versión en consecuencia, según los argumentos de la línea de comando.

Como la aplicación es de código abierto, también he creado una versión para incrementar el número de versión utilizando el formato (versión principal). (Versión secundaria). ([Año] [día de año]). (Incremento) . Más información sobre esto y el código revisado está disponible en mi entrada de blog, Assembly Version Numbers y .NET .

Actualización: he puesto el código de mi versión modificada de la aplicación UpdateVersion en GitHub: https://github.com/munr/UpdateVersion

Puede hacer versiones más avanzadas utilizando scripts de comstackción como Build Versioning