Posso incrementare automaticamente la versione di build del file quando utilizzo Visual Studio?

https://stackoverflow.com/questions/356543

21-08-2019
|

Domanda

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

Se cerco le proprietà di say C:\Windows\notepad.exe, la scheda Versione fornisce "Versione file:5.1.2600.2180".Vorrei ottenere questi fantastici numeri anche nella versione della mia dll, non nella versione 1.0.0.0, che ammettiamolo è un po' noiosa.

Ho provato alcune cose, ma non sembra essere una funzionalità pronta all'uso, o forse sto solo cercando nel posto sbagliato (come al solito).

Mi occupo principalmente di progetti web....

Li ho guardati entrambi:

e non potevo credere che uno sforzo così grande per fare qualcosa fosse una pratica standard.

MODIFICARE:Per quanto ne so, non funziona in VS2005 (http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx)

Soluzione

In Visual Studio 2008, le seguenti opere.

Trova file AssemblyInfo.cs e trovare queste 2 linee:

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

Si potrebbe provare a cambiare questo:

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

Ma questo non ti darà il risultato desiderato, si finirà con un prodotto Versione di 1.0. * e un file versione di 1.0.0.0 . Non quello che volete!

Tuttavia, se si rimuove la seconda di queste linee e solo:

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

Quindi il compilatore impostare la versione di file per essere uguale alla versione del prodotto e si otterrà il risultato desiderato di una versione del prodotto e del file automaticamente incremento che sono in sincronia. Per esempio. 1.0.3266.92689

Altri suggerimenti

aprire il file AssemblyInfo.cs e cambiare

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

è possibile farlo in IDE andando a progetto -> Proprietà -> informazioni di montaggio

Questo tuttavia si consente solo a incremento automatico la versione di montaggio e vi darà la

Assemblea File Version: Un jolly ( "*") non è consentito in questo campo

finestra di messaggio se si tenta inserire un * nel campo versione del file.

Quindi, solo aprire le AssemblyInfo.cs e farlo manualmente.

Un'altra opzione per cambiare i numeri di versione in ogni generazione è quello di utilizzare il Versione MSBuild .Community.Tasks . Basta scaricare il programma di installazione, installarlo, quindi adattare il seguente codice e incollarlo dopo <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> nel .csproj file:

<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: Adattare la proprietà StartDate al vostro locale. Attualmente non usa le impostazioni cultura invarianti.

Per la terza generazione su 14 Gennaio 2010, questo crea un VersionInfo.cs con questo contenuto:

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

Questo file deve poi essere aggiunto al progetto (tramite Aggiungi elemento esistente ), e il AssemblyVersion e AssemblyFileVersion linee devono rimuovere da AssemblyInfo.cs.

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

mi si avvicinò con una soluzione simile per i cristiani, ma senza a seconda delle mansioni Comunità MSBuild, questa non è un'opzione per me come io non voglio installare questi compiti per tutti i nostri sviluppatori.

Io sono la generazione del codice e la compilazione di un'Assemblea e voglio incremento automatico i numeri di versione. Tuttavia, non posso usare il VS 6.0. * AssemblyVersion trucco, come si auto-incrementi di costruire numeri ogni giorno di compatibilità e si rompe con assemblee che utilizzano un numero di build più vecchia. Invece, voglio avere un AssemblyVersion hard-coded, ma un AssemblyFileVersion incremento automatico. Ho compiuto questo specificando AssemblyVersion nelle AssemblyInfo.cs e generando un VersionInfo.cs in MSBuild come questo,

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

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

Installare il costruire Versione incremento aggiuntivo. Ti dà modo più controllo che l'opzione *.

Per ottenere i numeri di versione cercano

 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 totale secondi nel corso della giornata. Quindi, se si compila a mezzanotte dovrebbe essere pari a zero.

C'è un versioni automatiche che supporta Visual Studio 2012, 2013, 2015 e 2017.

Colpi di Schermo

L'impostazione di un * nel numero di versione in AssemblyInfo o sotto le proprietà del progetto, come descritto negli altri posti 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 è possibile utilizzare il seguente: incremento automatico Visual Studio 2005 versione build e la revisione numero sulla compilazione tempo .

Ma essere consapevoli del fatto che cambiando il numero di versione automaticamente non è raccomandato per assembly con nome. La ragione è che tutti i riferimenti a tale assemblea devono essere aggiornati ogni volta che il gruppo di riferimento è ricostruito a causa del fatto che i riferimenti assembly con nome sono sempre un riferimento a una versione assembly specifico. Microsoft si cambia il numero di versione dei assembly .NET Framework solo se ci sono cambiamenti nelle interfacce. (NB:. Sto ancora cercando il link in MSDN dove ho letto che)

Per ottenere incrementando le informazioni (DateTime) nella proprietà AssemblyFileVersion che ha il vantaggio di non rompere eventuali dipendenze.

Sulla soluzione di Boog (non ha funzionato per me, forse a causa di VS2008?), È possibile utilizzare una combinazione di un evento di pre-compilazione generazione di un file, aggiungendo che il file (comprese le sue proprietà di versione) e quindi utilizzando un modo per leggere quei valori di nuovo. Cioè ..

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 risultante VersionInfo.cs (Proprietà sottocartella) nel progetto

Il codice per ottenere Risalgo (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 si crea un sacco di forza-ricostruisce (dal momento che un file è sempre in movimento).

Si potrebbe rendere più intelligente per esempio se aggiornare solo il VersionInfo.cs file di ogni pochi minuti / ore (utilizzando un file temporaneo e poi copiare / sovrascrivere i veri VersionInfo.cs se viene rilevato un cambiamento abbastanza grande). Ho fatto questo una volta abbastanza successo.

Imposta il numero di versione a "1.0. *" E sarà automaticamente compilare il ultimi due numero con la data (in giorni da un certo punto) e il tempo (la metà dei secondi dalla mezzanotte)

E 'nelle proprietà del progetto in Pubblica

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

torta supporta i file AssemblyInfo patch. Con la torta in mani hai infiniti modi per implementare automatica di incremento di versione.

Semplice esempio di incrementare versione come compilatore C # fa:

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 montaggio. Le migliori pratiche è quello di bloccare numero di versione principale e lasciare rimanendo con zeri (come "1.0.0.0").
FileVersion - è la versione del file assembly

Si noti che è possibile patch non solo le versioni ma anche tutte le altre informazioni necessarie .

Vai al progetto | Proprietà e poi dell'Assemblea informazioni e poi dell'Assemblea di versione e porre * nel l'ultimo o il secondo-a-ultima casella (non è possibile incremento automatico della maggiore o componenti minori).

Utilizzare l'attività AssemblyInfo dalle Attività MSBuild comunitari ( http://msbuildtasks.tigris.org/ ) progetto e integrarlo nel proprio file .csproj / vbproj.

Ha un certo numero di opzioni, tra cui uno di legare il numero di versione per la data e l'ora del giorno.

consigliato.

A partire da ora, per la mia domanda,

string ver = Application.ProductVersion;

ritorna ver = 1.0.3251.27860

Il valore 3251 è il numero di giorni trascorsi dal 1/1/2000. Io lo uso per mettere una data di creazione versione nella schermata iniziale della mia candidatura. Quando si tratta di un utente, posso chiedere la data di creazione, che è più facile comunicare che qualche numero lungo.

(Sono un dept one-man supporto di una piccola azienda. Questo approccio non può funzionare per voi.)

La modifica della AssemblyInfo lavora in VS2012. Sembra strano che non c'è più il supporto per questo in Visual Studio, si potrebbe pensare che questa è stata una parte fondamentale del processo di generazione / release.

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

Questa è una specie di sperimentazione, ma mi piace. Ispirato da Jeff Atwood @ CodingHorror ( link ).

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

mans poveri zero padding (con la stupida leader 1 s)
quasi-leggibile locale DateTime incorporato nel numero di versione
lasciando versione maggiore da solo per davvero grandi cambiamenti rottura.

Aggiungi un nuovo elemento al progetto, selezionare Generali -.> Modelli di testo, il nome è qualcosa di simile a CustomVersionNumber e (se del caso) commentare la AssemblyVersion e AssemblyFileVersion in Properties/AssemblyInfo.cs

Poi, quando si salva il file, o la costruzione del progetto, questo rigenererà un file .cs situato come un sub-item sotto il .tt file 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, è possibile utilizzare il 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 chiamarlo dal modulo di carico.
Con questo codice è possibile aggiornare qualsiasi parte del file in informazioni AssemblyInfo.cs (ma è necessario utilizzare la struttura delle directory "standard").

AssemblyInfoUtil . Gratuito. Open-source.

Sto utilizzando questo approccio https://stackoverflow.com/a/827209/3975786 posizionando il T4 modello in una "soluzione Items" e di utilizzarlo con "Aggiungi come link" all'interno di ogni progetto.

Forse è troppo tardi per rispondere qui, ma la speranza che risolverà i problemi frenetico di qualcuno.

Un modo automatico per cambiare la versione montaggio di tutti i progetti che utilizzano lo script PowerShell. In questo articolo sarà risolvere molti dei vostri problemi.

Ogni volta che faccio un accumulo si auto-incrementi la cifra meno significativa.

Non ho idea di come aggiornare gli altri, ma si dovrebbe almeno essere vedendo che già ...

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

Scaricamento Applicazione
aggiungi la seguente riga alla riga di comando dell'evento precompilato

C: emp\IncrementFileVersion.exe $(SolutionDir)\Properties\AssemblyInfo.cs
Costruisci il progetto

Per semplicità, l'app genera messaggi solo in caso di errore, per confermare che ha funzionato correttamente dovrai controllare la versione del file in "Informazioni sull'assembly"

Nota :Sarà necessario ricaricare la soluzione in Visual Studio affinché il pulsante "Informazioni sull'assembly" possa compilare i campi, tuttavia il file di output avrà la versione aggiornata.

Per suggerimenti e richieste scrivetemi a telson_alva@yahoo.com

In Visual Studio 2019

Non mi bastava aggiungere

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

Durante la costruzione mi genera questo errore

La stringa della versione specificata non è conforme al formato richiesto

Soluzione

Il formato è stato finalmente accettato dopo averlo impostato Deterministic A False In project.csproj

<Deterministic>false</Deterministic>

Modificare:

Per qualche motivo l'impostazione Deterministic A False ho incasinato il mio file di configurazione caricandolo e salvandolo in posizioni diverse.

Soluzione alternativa:

Ho impostato un evento post-build per incrementare il numero di revisione:

Script batch dell'evento post-compilazione

Questo chiama uno script PowerShell denominato autoincrement_version.ps1 passando come argomento il percorso di AssemblyInfo.cs

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

Scrittura Poweshell

Incrementa automaticamente il numero di revisione utilizzando 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

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow

Posso incrementare automaticamente la versione di build del file quando utilizzo Visual Studio?

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

In Visual Studio 2019

Soluzione

Modificare:

Soluzione alternativa:

Script batch dell'evento post-compilazione

Scrittura Poweshell

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