Mi stavo solo 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 del file: 5.1.2600.2180". Vorrei ottenere questi numeri interessanti 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 guardando 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 crederci, tanto lo sforzo di fare qualcosa è una pratica standard.

EDIT: non funziona in VS2005 per quanto ne so ( 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")]

Puoi 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 1.0. * E una versione del file 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 otterrai il risultato desiderato di un prodotto con incremento automatico e versione del file 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")]

per

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

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

Questo, tuttavia, ti consentirà solo di incrementare automaticamente la versione dell'Assemblea e ti darà il

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

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

Quindi basta aprire assemblyinfo.cs e farlo manualmente.

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

<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 alle impostazioni internazionali.Attualmente non utilizza la cultura invariante.

Per la terza build del 14 gennaio 2010, questo crea un VersionInfo.cscon 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 AssemblyVersione AssemblyFileVersiondevono essere rimosse daAssemblyInfo.cs .

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

Ho trovato una soluzione simile ai cristiani, ma senza dipendere dalle attività di Community MSBuild, questa non è un'opzione per me in quanto non voglio installare queste attività per tutti i nostri sviluppatori.

Sto generando codice e compilando un assembly e desidero incrementare automaticamente i numeri di versione. Tuttavia, non posso usare il trucco VS 6.0. * AssemblyVersion in quanto 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 un AssemblyVersion codificato ma un AssemblyFileVersion con incremento automatico. Ho ottenuto questo risultato specificando AssemblyVersion in AssemblyInfo.cs e generando un VersionInfo.cs in MSBuild in questo modo,

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

Ciò 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 compilarlo.

Installa il componente aggiuntivo Build Version Increment . Ti dà molto più controllo rispetto all'opzione *.

Per ottenere i numeri di versione, provare

 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.

Esiste un'estensione di Visual Studio Versioni automatiche che supporta Visual Studio (2012, 2013, 2015) 2017 e 2019.

Schermate

L'impostazione di un * 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.

Dopo tutto non ha funzionato in VS 2005 (ma in VS 2003 e VS 2008). Per VS 2005 è possibile utilizzare quanto segue: Incremento automatico della versione di Visual Studio 2005 e numero di revisione al momento della compilazione .

Tuttavia, tenere 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 di assembly con nome sicuro sono sempre un riferimento a una specifica versione dell'assembly. Microsoft stessa modifica il numero di versione degli assembly .NET Framework solo in caso di modifiche alle interfacce. (NB: sto ancora cercando il link in MSDN dove l'ho letto.)

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 usare una combinazione di un evento pre-build che genera un file, aggiungendo quel file (incluse le proprietà della sua versione) e quindi usando un modo per 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 recuperare la data (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 molte ricostruzioni forzate (poiché un file cambia sempre).

Potresti renderlo più intelligente, ad esempio, se aggiorni il file VersionInfo.cs solo ogni pochi minuti / ore (utilizzando un file temporaneo e quindi copiando / sovrascrivendo il VersionInfo.cs reale se viene rilevata una modifica abbastanza grande). L'ho fatto una volta abbastanza bene.

Impostare il numero di versione su "1.0. *" E riempirà automaticamente gli ultimi due numeri con la data (in giorni da un certo punto) e l'ora (metà dei secondi da mezzanotte)

È nelle proprietà del progetto in Pubblica

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

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

Un semplice esempio di incremento della versione come il 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 dell'assembly. La migliore pratica è bloccare il numero di versione principale e lasciare il resto con zero (come "1.0.0.0").
• FileVersion - è la versione del file assembly.

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

Vai a Progetto | Proprietà, quindi Informazioni sull'assemblaggio, quindi Versione dell'assemblaggio e inserire un * nell'ultima o nella penultima casella (non è possibile incrementare automaticamente i componenti principali o minori).

Utilizzare l'attività AssemblyInfo dalle attività della community di MSBuild ( http://msbuildtasks.tigris.org/ ) e integrarlo nel file .csproj / .vbproj.

Ha una serie di opzioni, tra cui una per legare il numero di versione alla data e all'ora del giorno.

Consigliato.

A partire da ora, per la mia applicazione,

string ver = Application.ProductVersion;

ritorna ver = 1.0.3251.27860

Il valore 3251 è il numero di giorni dall'1 / 1/2000. Lo uso per inserire una data di creazione della versione nella schermata iniziale della mia applicazione. Quando ho a che fare con un utente, posso chiedere la data di creazione che è più facile da comunicare rispetto a un numero lungo.

(Sono un dipartimento individuale 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, penseresti che questa fosse una parte fondamentale del processo di compilazione / rilascio.

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

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

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

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

Aggiungere un nuovo elemento al progetto, selezionare Generali -> modello di testo, il nome è qualcosa di simile CustomVersionNumbere commentare (se del caso) la AssemblyVersione AssemblyFileVersionin Properties/AssemblyInfo.cs.

Quindi, quando si salva questo file o si .cscrea il progetto, questo rigenera un file situato come sotto-elemento nel .ttfile 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}" #>")]

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

1. Scarica l' applicazione

2. aggiungere la seguente riga alla riga di comando dell'evento pre-build

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

3. Costruisci il progetto

Per semplificare, l'app genera messaggi solo 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 popolare 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 è stato abbastanza per me aggiungere

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

Quando lo costruisco mi lancia questo errore

La stringa di versione specificata non è conforme al formato richiesto

Soluzione

Il formato è stato infine accettato dopo essere stata impostata Deterministica Falseinproject.csproj

<Deterministic>false</Deterministic>

Modificare:

Per qualche motivo, impostare DeterministicsuFalse ho incasinare il mio file di configurazione caricandolo e salvandolo in diverse posizioni.

Soluzione:

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

Script batch di eventi post-build

Questo chiama uno script PowerShell chiamato autoincrement_version.ps1passando come argomento il percorso diAssemblyInfo.cs

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

Script Poweshell

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

Forse, per questa attività, è possibile utilizzare il codice in questo modo:

    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 è possibile aggiornare qualsiasi parte delle informazioni sui file in AssemblyInfo.cs (ma è necessario utilizzare una struttura di directory "standard").

AssemblyInfoUtil . Gratuito. Open-source.

Sto usando questo approccio https://stackoverflow.com/a/827209/3975786 inserendo il modello T4 in "Elementi soluzione" e utilizzandolo con "Aggiungi come collegamento" all'interno di ciascun progetto.

Forse è troppo tardi per rispondere qui, ma spero che risolva il frenetico problema 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 faccio una build, aumenta automaticamente la cifra meno significativa.

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

Per chiunque utilizzi Tortoise Subversion, è possibile associare uno dei numeri di versione al numero di revisione del codice sorgente di sovversione. Lo trovo molto utile (anche ai revisori piace molto!). Puoi farlo chiamando l'utilità WCREV nella tua pre-build e generando AssemblyInfo.cs da un modello.

Se il tuo modello si chiama AssemblyInfo.wcrev e si trova nella normale directory AssemblyInfo.cs e tartaruga si trova nella directory di installazione predefinita, il comando Pre-Build è simile al seguente (NB tutto su una riga):

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

Il file modello includerebbe la stringa di sostituzione del token wcrev: $ WCREV $
ad es

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

Nota:
poiché AssemblyInfo.cs viene ora generato, non si desidera che venga controllato dalla versione.