Posso aumentare automaticamente la versione di build del file quando si utilizza Visual Studio?

Mi stavo chiedendo come avrei potuto incrementare automaticamente la build (e la versione?) Dei miei file usando Visual Studio (2005).

Se cerco le proprietà di dire C:\Windows\notepad.exe , la scheda Versione fornisce “Versione file: 5.1.2600.2180”. Mi piacerebbe avere questi numeri fantastici anche nella versione della mia dll, non nella versione 1.0.0.0, che ammettiamolo è un po ‘noiosa.

Ho provato un paio di cose, ma non sembra essere una funzionalità out-of-box, o forse sto solo cercando nel posto sbagliato (come al solito).

Lavoro principalmente con progetti web ….

Ho guardato entrambi:

  1. http://www.codeproject.com/KB/dotnet/Auto_Increment_Version.aspx
  2. http://www.codeproject.com/KB/dotnet/build_versioning.aspx

e non potevo credere che un tale sforzo per fare qualcosa fosse una pratica standard.

EDIT: Non funziona in VS2005 per quanto posso dire ( http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx )

In Visual Studio 2008, i seguenti lavori.

Trova il file AssemblyInfo.cs e trova queste 2 righe:

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

Potresti provare a cambiarlo in:

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

Ma questo non ti darà il risultato desiderato, ti ritroverai con una versione del prodotto di 1.0. * E una versione file di 1.0.0.0 . Non quello che vuoi!

Tuttavia, se rimuovi la seconda di queste righe e hai solo:

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

Quindi il compilatore imposterà la versione del file in modo che sia uguale alla versione del prodotto e otterrete il risultato desiderato di un prodotto che incrementa automaticamente la versione del file e che sono sincronizzati. Ad esempio, 1.0.3266.92689

aprire il file AssemblyInfo.cs e modificare

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

puoi farlo in IDE andando su project -> properties -> assembly information

Ciò tuttavia ti consentirà solo di incrementare automaticamente la versione dell’Assembly e ti darà il

Versione file assembly: un carattere jolly (“*”) non è consentito in questo campo

message box se provi a inserire un * nel campo della versione del file.

Quindi, apri l’assemblyinfo.cs e fallo manualmente.

Un’altra opzione per modificare i numeri di versione in ogni build consiste nell’utilizzare l’attività Version di MSBuild.Community.Tasks . Basta scaricare il loro programma di installazione, installarlo, quindi adattare il seguente codice e incollarlo dopo nel file .csproj :

           

Nota: adattare la proprietà StartDate alle impostazioni locali. Al momento non usa la cultura invariante.

Per la terza build, il 14 gennaio 2010, viene creato un VersionInfo.cs con questo contenuto:

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

Questo file deve quindi essere aggiunto al progetto (tramite Aggiungi elemento esistente ) e le righe AssemblyVersion e AssemblyFileVersion devono essere rimosse da AssemblyInfo.cs .

I diversi algoritmi per la modifica dei componenti della versione sono descritti in $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm e Proprietà versione .

Ho trovato una soluzione simile ai cristiani, ma senza dipendere dalle attività di MSBuild della comunità, questa non è un’opzione per me poiché non voglio installare queste attività per tutti i nostri sviluppatori.

Sto generando codice e compilando un assembly e voglio incrementare automaticamente i numeri di versione. Tuttavia, non riesco a utilizzare VS 6.0. * AssemblyVersion, poiché incrementa automaticamente i numeri di build ogni giorno e interrompe la compatibilità con gli assembly che utilizzano un numero di build precedente. Invece, voglio avere una AssemblyVersion hard-coded ma una AssemblyFileVersion auto-incrementante. Ho compiuto questo specificando AssemblyVersion in AssemblyInfo.cs e generando un VersionInfo.cs in MSBuild come questo,

   $([System.DateTime]::Now.ToString("yy")) $([System.DateTime]::Now.ToString("MM")) $([System.DateTime]::Now.ToString("dd"))  [assembly:System.Reflection.AssemblyFileVersion("$(Year).$(Month).$(Date).$(Time)")]      

Questo genererà un file VersionInfo.cs con un attributo Assembly per AssemblyFileVersion in cui la versione segue lo schema di YY.MM.DD.TTTT con la data di costruzione. È necessario includere questo file nel progetto e creare con esso.

Installare il componente aggiuntivo Incremento versione build . Ti dà molto più controllo rispetto all’opzione *.

Prova ad ottenere i numeri di versione

  System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly(); System.Reflection.AssemblyName assemblyName = assembly.GetName(); Version version = assemblyName.Version; 

Per impostare il numero di versione, creare / modificare AssemblyInfo.cs

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

Inoltre, come nota a margine, il terzo numero è il numero di giorni dal 2/1/2000 e il quarto numero è la metà della quantità di secondi totali nel giorno. Quindi se compili a mezzanotte dovrebbe essere zero.

L’impostazione di * nel numero di versione in AssemblyInfo o nelle proprietà del progetto come descritto negli altri post non funziona con tutte le versioni di Visual Studio / .NET.

Afaik non ha funzionato in VS 2005 (ma in VS 2003 e VS 2008). Per VS 2005 è ansible utilizzare quanto segue: Incremento automatico Visual Studio 2005 versione build e numero di revisione in fase di compilazione .

Tuttavia, tieni presente che la modifica automatica del numero di versione non è consigliata per gli assembly con nome sicuro. Il motivo è che tutti i riferimenti a tale assembly devono essere aggiornati ogni volta che l’assembly di riferimento viene ricostruito a causa del fatto che i riferimenti all’assembly con nome sicuro sono sempre un riferimento a una specifica versione dell’assembly. Microsoft stessa modifica il numero di versione degli assembly di .NET Framework solo se sono presenti modifiche nelle interfacce. (NB: sto ancora cercando il link in MSDN dove ho letto quello.)

Imposta il numero di versione su “1.0. *” E questo riempirà automaticamente gli ultimi due numeri con la data (in giorni da qualche punto) e l’ora (metà dei secondi da mezzanotte)

Per ottenere informazioni incrementali (DateTime) nella proprietà AssemblyFileVersion che presenta il vantaggio di non interrompere alcuna dipendenza.


Basandosi sulla soluzione di Boog (non ha funzionato per me, forse a causa di VS2008?), Puoi utilizzare una combinazione di un evento di pre-generazione che genera un file, aggiungendo quel file (incluse le sue proprietà di versione) e quindi usando un modo di leggere quei valori di nuovo. Questo è..

Pre-Build-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 

Includere il file VersionInfo.cs risultante (sottocartella Proprietà) nel progetto

Codice per ottenere la Data indietro (anni fino a secondi):

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

Non molto comodo .. inoltre, non so se crea un sacco di ricostruzioni di forza (dal momento che un file cambia sempre).

Ad esempio, è ansible renderlo più intelligente se si aggiorna il file VersionInfo.cs ogni pochi minuti / ore (utilizzando un file temporaneo e quindi copiando / sovrascrivendo il file VersionInfo.cs reale se viene rilevata una modifica sufficientemente grande). L’ho fatto una volta abbastanza bene.

C’è un’estensione per studio visivo Versioni automatiche che supporta Visual Studio 2012, 2013, 2015 e 2017.

Colpi sullo schermo inserisci la descrizione dell'immagine qui

inserisci la descrizione dell'immagine qui

È nelle proprietà del progetto in Pubblica

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

Cake supporta patch di AssemblyInfo. Con la torta in mano hai infiniti modi per implementare l’incremento automatico della versione.

Semplice esempio di versione incrementativa come il compilatore 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); }); 

Qui:

  • Versione – è la versione di assemblaggio. La migliore pratica consiste nel bloccare il numero di versione principale e lasciare il resto con zero (come “1.0.0.0”).
  • FileVersion – è la versione del file di assembly.

Nota che puoi applicare patch non solo alle versioni ma anche a tutte le altre informazioni necessarie .

Vai a Progetto | Proprietà e poi Informazioni sull’assemblaggio e poi Assemblare Versione e inserire un * nell’ultima o nella penultima casella (non è ansible incrementare automaticamente i componenti Maggiore o Minore).

Utilizzare l’attività AssemblyInfo dal progetto Attività community di MSBuild ( http://msbuildtasks.tigris.org/ ) e integrarlo nel file .csproj / .vbproj.

Ha un numero di opzioni, incluso uno per bind il numero di versione alla data e ora del giorno.

Consigliato.

A partire da ora, per la mia domanda,

 string ver = Application.ProductVersion; 

restituisce ver = 1.0.3251.27860

Il valore 3251 è il numero di giorni dall’1 / 1/2000. Lo uso per mettere una data di creazione della versione sullo splash screen della mia applicazione. Quando si tratta di un utente, posso chiedere la data di creazione che è più facile da comunicare rispetto a un numero lungo.

(Sono un addetto a un solo uomo che supporta una piccola azienda. Questo approccio potrebbe non funzionare per te.)

La modifica di AssemblyInfo funziona in VS2012. Sembra strano che non ci sia più supporto per questo in Visual Studio, si potrebbe pensare che questa fosse una parte fondamentale del processo di generazione / rilascio.

Come ottenere la versione {major}.{year}.1{date}.1{time}

Questo è un po ‘sperimentale, ma mi piace. Ispirato a Jeff Atwood @ CodingHorror ( link ).

Il numero di versione risultante diventa 1.2016.10709.11641 (che significa 2016-07-09 16:41), che consente

  • povero equipaggia lo zero padding (con gli stupidi primi 1 s)
  • DateTime locale leggibile quasi umano incorporato nel numero di versione
  • lasciando la versione Major da sola per cambiamenti davvero importanti.

Aggiungi un nuovo elemento al tuo progetto, seleziona Generale -> Modello di testo, CustomVersionNumber nome a CustomVersionNumber e (dove applicabile) commenta AssemblyVersion e AssemblyFileVersion in Properties/AssemblyInfo.cs .

Quindi, quando si salva questo file o si crea il progetto, questo rigenererà un file .cs che si trova come sottoelemento nel file .tt creato.

 < #@ 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}" #>")] 

Forse, per questo compito, puoi usare un codice come questo:

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

e chiamalo dal caricamento del modulo.
Con questo codice è ansible aggiornare qualsiasi parte delle informazioni sui file in AssemblyInfo.cs (ma è necessario utilizzare la struttura di directory “standard”).

AssemblyInfoUtil . Gratuito. Open-source.

Sto utilizzando questo approccio https://stackoverflow.com/a/827209/3975786 posizionando il modello T4 in “Elementi della soluzione” e usandolo con “Aggiungi come collegamento” all’interno di ciascun progetto.

Forse è troppo tardi per rispondere qui, ma spero che risolva il problema frenetico di qualcuno.

Un modo automatico per cambiare la versione dell’assembly di tutti i tuoi progetti usando lo script PowerShell. Questo articolo risolverà molti dei tuoi problemi.

Ogni volta che eseguo una build, incrementa automaticamente la cifra meno significativa.

Non ho idea di come aggiornare gli altri, ma dovresti almeno vederlo già …

Ho creato un’applicazione per incrementare automaticamente la versione del file.

  1. Scarica l’ applicazione
  2. aggiungere la seguente riga alla riga di comando pre-build dell’evento

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

  3. Costruisci il progetto

Per semplificare l’applicazione, l’app lancia solo messaggi in caso di errore, per confermare che ha funzionato correttamente, dovrai controllare la versione del file in “Informazioni sull’assemblaggio”

Nota: sarà necessario ricaricare la soluzione in Visual Studio per il pulsante “Informazioni sull’assemblaggio” per compilare i campi, tuttavia il file di output avrà la versione aggiornata.

Per suggerimenti e richieste scrivetemi a telson_alva@yahoo.com