Best practice / guida per il mantenimento numeri di versione di montaggio

StackOverflow https://stackoverflow.com/questions/3768261

Domanda

sto cercando puntatori, suggerimenti, e anche la dettatura su come gestire i tre diversi numeri di versione di montaggio per un NET montaggio. La versione del prodotto è la più semplice, in quanto questo sembra normalmente sarebbe dettata da parte delle imprese. Poi, la versione del file sembra essere per il controllo delle versioni tra le distribuzioni, in cui la versione montaggio vero e proprio viene utilizzato solo quando il trasporto.

In questo momento mi sto solo cercando un semplice mezzo di etichettatura di test e release di manutenzione di un assieme in cui nessuno dipendono, quindi mi sto guardando incremento automatico di build e numeri di revisione sulla versione del file, e per il rilascio finale, copiare la versione del file corrente alla versione di assembly. Il prodotto è in uso in produzione, ma ancora in fase di sviluppo - si sa -. Uno di quelli piccola azienda, verificate situazioni di infrastrutture di controllo delle modifiche

È stato utile?

Soluzione

Versioning è qualcosa che io sono molto appassionato e hanno trascorso molto tempo cercando di venire con un facile da usare sistema di controllo delle versioni. Da quello che ha già detto nella tua domanda, è chiaro che avete capito un punto importante, i numeri di versione di montaggio non sono sinonimi con la versione del prodotto. Uno è tecnicamente guidato, e l'altro è guidato dal business.

Di seguito presuppone che si utilizzi una qualche forma di controllo del codice sorgente e un build server. Per contesto usiamo TeamCity e Subversion / Git. TeamCity è gratuita per un piccolo numero (10) di progetti ed è un ottimo build server, ma ce ne sono altri, alcuni dei quali sono completamente gratuito.

Cosa si intende un numero di versione

Quello che un mezzo di versione per una persona può significare qualcosa di diverso da un altro, la struttura generale è maggiore, minore, macro, micro. Il mio modo di vedere un numero di versione è una scomposizione in due parti. La prima metà descrive la versione principale (Major) e gli eventuali aggiornamenti chiave (minore). La seconda metà indica quando è stato costruito e ciò che la versione del codice sorgente è stato. I numeri di versione anche cose cattive diverse a seconda del contesto, è un'API, Web App, ecc

Major.Minor.Build.Revision

  • Revision Questo è il numero preso dal controllo di origine per identificare ciò che è stato effettivamente costruito.
  • Build Si tratta di un numero sempre crescente che può essere usato per trovare una particolare generazione su server di build. Si tratta di un numero importante perché il build server potrebbe aver costruito la stessa fonte due volte con un diverso insieme di parametri. Utilizzando il numero di build in insieme al numero sorgente consente di identificare ciò che è stato costruito e come.
  • Minor Questo dovrebbe cambiare solo quando v'è un cambiamento significativo per l'interfaccia pubblica. Ad esempio, se è un API, codice sarebbe consumare essere ancora in grado di compilare? Questo numero deve essere riportato a zero quando il numero maggiore modifiche.
  • Major indica quale versione del prodotto ci si trova. Ad esempio la Maggiore di tutta la VisualStudio 2008 assiemi è 9 e VisualStudio 2010 è 10.

L'eccezione alla regola

Ci sono sempre eccezioni alla regola e si dovrà adattare come ci si imbatte in loro. Il mio approccio originale era basato sull'utilizzo di sovversione ma di recente mi sono trasferito a Git. controllo del codice sorgente come la sovversione e la fonte di sicurezza che utilizzano un repository centrale ha un numero che può essere utilizzato per identificare un particolare insieme di fonti da un dato momento. Questo non è il caso di un controllo origine distribuito come Git. Perché Git utilizza i repository distribuiti che si trovano su ogni macchina di sviluppo non v'è alcuna automatica dei numeri che è possibile utilizzare l'incremento, v'è un hack che utilizza il numero di check-in, ma è brutto. A causa di questo ho dovuto evolversi il mio approccio.

Major.Minor.Macro.Build

Il numero di revisione è ormai andato, accumulo si è spostata al punto in cui la revisione usato per essere e Macro è stato inserito. È possibile utilizzare la macro come si vede in forma, ma il più delle volte lo lascio da solo. Perché usiamo TeamCity le informazioni perse dal numero di revisione può essere trovata nella build, lo fa significa che esiste un processo in due fasi, ma non abbiamo perso nulla ed è un compromesso accettabile.

Cosa impostare

La prima cosa da capire è che la versione Assemblea, della versione dei file e versione del prodotto non deve necessariamente corrispondere. Non sto sostenendo con diverse serie di numeri, ma rende la vita molto più facile quando si effettuano piccole modifiche a un assembly che non intacchi nessuno interfacce pubbliche che non si è costretti a ricompilare assembly dipendenti. L'I affare senso con questo è quello di impostare solo i numeri maggiore e minore in Assemblea Version ma per impostare tutti i valori nel file versione. Ad esempio:

  • 1.2.0.0 (AssemblyVersion)
  • 1.2.3.4 (FileVersion)

Questo ti dà la possibilità di implementare hot fix, che non rompere il codice esistente perché le versioni di montaggio non corrispondono, ma permetterà di vedere la revisione / build di un assembly, cercando in suo numero di versione del file. Si tratta di un approccio comune e può essere visto su alcune assemblee open source quando si guardano i dettagli di montaggio.

È come il piombo squadra avrebbe bisogno di essere responsabile per incrementare il numero minore quando mai è necessario un cambiamento di rottura. Una soluzione a stendere un cambiamento necessario per un'interfaccia, ma non rompere il codice precedente è quello di segnare quella attuale come obsoleto e la creazione di una nuova interfaccia. Ciò significa che il codice esistente è avvertito che il metodo è obsoleto e potrebbe essere rimosso in qualsiasi momento, ma non richiede di rompere tutto e subito. È quindi possibile rimuovere il metodo obsoleto, quando tutto è stato migrato.

Come legare insieme

Si potrebbe fare tutto quanto sopra manualmente, ma sarebbe molto tempo, il seguente è il modo in cui automatizzare il processo. Ogni passo è eseguibile.

  • AssemblyVersion e AssemblyFileVersion attributi da tutto il progetto AssemblyInfo file Cs.
  • Creare un file di informazioni gruppo di comuni (chiamarlo VersionInfo.cs) e aggiungerlo come un elemento collegato a tutti i vostri progetti.
  • Aggiungi attributi AssemblyVersion e AssemblyFileVersion alla versione con valori di "0.0.0.0".
  • Creare un progetto MsBuild che costruisce il vostro file di soluzione.
  • Aggiungi in un compito prima della build che aggiorna i VersionInfo.cs. Ci sono una serie di librerie open source MSBuild che includono un compito AssemblyInfo che può impostare il numero di versione. Basta impostarlo su un numero arbitrario e di prova.
  • Aggiungi un gruppo di proprietà che contiene una proprietà per ciascuno dei segmenti del numero di build. Questo è dove si imposta la maggiore e minore. Il numero di build e la revisione dovrebbe essere passato come argomento.

Con la sovversione: 

<PropertyGroup>
    <Version-Major>0</Version-Major>
    <Version-Minor>0</Version-Minor>
    <Version-Build Condition=" '$(build_number)' == '' ">0</Version-Build>
    <Version-Build Condition=" '$(build_number)' != '' ">$(build_number)</Version-Build>
    <Version-Revision Condition=" '$(revision_number)' == '' ">0</Version-Revision>
    <Version-Revision Condition=" '$(revision_number)' != '' ">$(revision_number)</Version-Revision>
</PropertyGroup>

Spero di essere stato chiaro, ma c'è un sacco coinvolti. Si prega di fare tutte le domande. Userò tutte le risposte per mettere un più conciso post sul blog insieme.

Altri suggerimenti

Il [AssemblyVersion] è un grosso problema in .NET. Una filosofia, incoraggiato da Microsoft è che si lascia auto-incremento, costringendo tutti progetti che dipendono dal gruppo di essere ricompilato. Opere okayish se si utilizza un server di build. Non è mai il sbagliato cosa da fare ma attenzione di persone che trasportano le spade.

L'altra, più strettamente associato con il suo significato reale è che il numero è rappresentativo per la versioni dell'interfaccia pubblica del complesso. In altre parole, si cambia solo quando si altera un'interfaccia pubblica o classe. Dal momento che solo un tale cambiamento richiede ai client dell'assemblea essere ricompilato. Questo deve essere fatto manualmente, però, il sistema di generazione non è abbastanza intelligente per rilevare automaticamente un tale cambiamento.

È possibile estendere ulteriormente questo approccio solo incrementando la versione quando il gruppo è stato distribuito su macchine al di fuori della vostra portata. Questo è l'approccio che utilizza Microsoft, i numeri di versione i loro assembly .NET molto raramente cambiano. Per lo più a causa del notevole dolore che provoca sui loro clienti.

Quindi, quello che Microsoft predica non è quello che pratiche. Il suo processo di costruzione e il controllo delle versioni è comunque senza precedenti, hanno anche un ingegnere del software dedicato che monitora il processo. non riusciva a lavorare così bene, il WaitHandle.WaitOne (int) di sovraccarico, in particolare, causato una discreta quantità di dolore . Risolto in .NET 4.0 con un approccio molto diverso, ma che sta diventando un po 'al di là del campo di applicazione.

E 'piuttosto a voi e la vostra fiducia in quanto bene è possibile controllare il processo di costruzione e dei cicli di rilascio per fare la propria scelta. Oltre a questo, l'incremento automatico [AssemblyFileVersion] automaticamente è molto appropriato. Con tuttavia l'inconveniente che questo è non supportato.

È possibile utilizzare la parte di costruzione del numero di versione per incremento automatico.

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

Nel vostro ambiente di una versione di prova è una versione che ha una versione build! = 0. Al rilascio si incrementa la parte minore e impostare la parte di costruzione a 0, questo è come si potrebbe identificare assemblee rilasciati.

Se si installa gli assembly nella Global Assembly Cache tuo GAC viene invaso da un sacco di versioni diffent nel corso del tempo, in modo da tenere a mente. Ma se si utilizzano le DLL solo localmente, credo che questa è una pratica buona.

In aggiunta al Bronumskis risposta , voglio sottolineare che, dopo lo standard Semantic Versioning 2.0 all'indirizzo semver.org , Major.Minor.Build.Revision sarebbe illegale a causa della regola che dopo l'aumento di un numero, tutti i valori regolari per il diritto avrebbe dovuto essere azzerato .

Un modo migliore seguendo lo standard sarebbe quella di utilizzare Major.Minor+Build.Revision. Questo non è obivously per l'uso in AssemblyVersionAttribute, ma un attributo personalizzato o di classe statica potrebbe essere usato al posto.

Semver in TeamCity dovrebbe essere disponibile tramite il Power Pack Meta-corridore. Per git con git-flow (soprattutto nel mondo .NET), ho trovato GitVersion di essere utile.

Non c'è una regola dura e veloce quando si tratta di assemblee delle versioni, quindi sentitevi liberi di provare che mai avrebbe funzionato per voi, ma vi suggerisco di fare uso di 4 parti approccio, come si avrà la flexiblity in caso si desidera apportare alcune modifiche in futuro.

... per es. 1.0.0 *

riservati - Questo aggiunge ulteriore flexiblity, in caso si vuole fare qualsiasi modifica futura. Ma come un difetto, tenerlo come 0.

Inoltre, in considerazione la firma il gruppo con una forte chiave. Questo risolverà il problema di conflitto di montaggio in caso si dispone di più versioni di assemblaggio registrata nel GAC. MSDN link

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top