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

numerador automatico en visual basic

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Puedo incrementar automáticamente la versión de compilación de archivos cuando uso Visual Studio? 23 respuestas

Quiero almacenar un conjunto de enteros que se incrementan automáticamente en el momento de la construcción:

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

Cuando compilo, se auto-incrementa la Revision . Cuando construyo el proyecto de instalación, 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 del usuario como:

Version: 0.1.92

¿Cómo se puede lograr esto?

Esta pregunta no solo pregunta cómo tener un número de versión que se incremente automáticamente, sino también cómo usar eso en el código, que es una respuesta más completa que otras.

Answer 1

Esta es mi implementación de la sugerencia T4 ... Esto incrementará el número de compilación cada vez que genere el proyecto independientemente de la configuración seleccionada (es decir, Debug | Release), e incrementará el número de revisión cada vez que realice una compilación de Release. Puede continuar actualizando los números de versión mayor y menor a través de la aplicación ➤ Información de ensamblaje ...

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

1. Elimine su archivo AssemblyInfo.cs existente.

2. Crea 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//(/"(?<major>//d+)//.(?<minor>//d+)//.(?<revision>//d+)//.(?<build>//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. Agrega esto a tu evento previo a la construcción:

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

Answer 2

Podría 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é por todas partes con la esperanza de encontrar alguna forma sencilla de hacerlo. Lo que encontré no parecía muy alentador: la gente escribe complementos de Visual Studio y tareas personalizadas de MsBuild solo para obtener un número entero (bueno, tal vez dos). Esto se sintió excesivo para un pequeño proyecto personal.

La inspiración vino de una de las discusiones de donde alguien sugirió que las plantillas T4 podrían hacer el trabajo. Y por supuesto que pueden. La solución requiere un esfuerzo mínimo y no requiere personalización de Visual Studio o del proceso de compilació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;
#>

Tendrá que decidir sobre el algoritmo de generación de número de versión. Para mí, fue suficiente para 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 versión está escrita en C #, para que pueda ajustarla fácilmente a sus necesidades. .

2. El archivo de arriba debe colocarse en uno de los proyectos. Creé un nuevo proyecto con solo este archivo para aclarar la técnica de administración de versiones. Cuando compilo este proyecto (en realidad ni siquiera necesito compilarlo: guardar el archivo es suficiente para desencadenar 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.

3. El siguiente paso es eliminar los atributos AssemblyVersion y AssemblyFileVersion de los archivos AssemblyInfo.cs en todos los proyectos que deban compartir la misma información de versión generada automáticamente. En su lugar, elija "Agregar elemento existente" para cada proyecto, navegue 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 (sin tareas personalizadas de MsBuild), y la información de la versión generada automáticamente no se agrega al control de fuente. Y, por supuesto, el uso de C # para el algoritmo de generación de versiones se abre para algoritmos de cualquier complejidad.

Answer 3

Puede realizar un control de versiones más avanzado utilizando scripts de compilación, como la creación de versiones.

Answer 4

Puedes intentar usar UpdateVersion por Matt Griffith . Es bastante viejo ahora, pero funciona bien. Para usarlo, simplemente necesita configurar un evento previo a la compilació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 comandos.

Como la aplicación es de código abierto, también he creado una versión para incrementar el número de versión usando el formato (Versión principal). (Versión menor). ([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, Números de versión de ensamblaje 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

Answer 5

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

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

Visual Studio incrementará el número final para ti 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 errores importantes que debes conocer.

Desde @ ashes999:

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

Desde @ BrainSlugs83:

Configurar solo el cuarto número para que sea * 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 construyó la solución tarde en un día un día, y temprano en un día al día siguiente, la versión posterior tendría un número de versión anterior. Recomiendo usar siempre XY* lugar de XYZ* porque su número de versión SIEMPRE aumentará de esta manera.

Answer 6

Si coloca un asterisco para la compilación y la revisión, visual studio utiliza la cantidad de días desde el 1 de enero de 2000 como el número de compilación y la cantidad de segundos desde la medianoche divididos por 2 como la revisión.

Una solución MUCHO mejor para salvar vidas es http://autobuildversion.codeplex.com/

Funciona como un encanto y es MUY flexible.

Answer 7

Utilice AssemblyInfo.cs

Cree el archivo en App_Code: y complete lo siguiente o use Google para otros atributos / propiedades posibles.

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.

Luego, si está trabajando en un sitio web, en cualquier página aspx o control, puede agregar en la etiqueta <Page>, lo siguiente:

CompilerOptions="<folderpath>/App_Code/AssemblyInfo.cs"

(reemplazando folderpath con la variable apropiada por supuesto).

No creo que necesite agregar opciones de compilador de ninguna manera para otras clases; Todos los que están en el Código de aplicación deben recibir la información de la versión cuando se compilan.

Espero que ayude.

Answer 8

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

Puede especificar todos los valores o puede aceptar el número de compilación predeterminado, el número de revisión, o ambos usando 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 compilació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 la versión secundaria, y acepta los números predeterminados de compilación y revisión. Un número de versión como [assembly: AssemblyVersion ("1.2.15. *")] Especifica 1 como versión principal, 2 como versión menor, 15 como número de compilación y acepta el número de revisión predeterminado. El número de compilación predeterminado se incrementa diariamente. El número de revisión predeterminado es aleatorio

Esto dice efectivamente, si coloca un 1.1. * En la información de ensamblaje, solo el número de compilación se autoincrementará, y no ocurrirá después de cada compilación, sino diariamente. El número de revisión cambiará cada compilación, pero de forma aleatoria, en lugar de incrementarse.

Esto es probablemente suficiente para la mayoría de los casos de uso. Si eso no es lo que está buscando, no podrá escribir un script que incremente automáticamente la versión # en el paso previo a la compilación.

Answer 9

• Star 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 script de @DrewChapin funciona, pero en mi estudio no puedo configurar diferentes modos para el evento de depuración previa de la depuración y el evento de precompilación de la versión anterior.

Así que cambié un poco el script ... 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+//.(?<revision>//d+)//.(?<build>//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;
#>