Meilleures pratiques / conseils pour maintenir les numéros de version de montage

https://stackoverflow.com/questions/3768261

04-10-2019
|

Question

Je cherche des pointeurs, des suggestions, et la dictée même sur la façon de gérer les trois numéros de version d'assemblage différents pour un assemblage .NET. La version du produit est le plus simple, comme cela semble normalement être dicté par les entreprises. Ensuite, la version du fichier semble être pour versioning entre les déploiements, où la version de montage réelle est utilisée uniquement lors de l'expédition.

En ce moment, je suis à la recherche d'un moyen simple de tester l'étiquetage et les versions de maintenance d'un ensemble sur lequel aucun dépendons donc je suis à la recherche à la construction auto-incrémentée et les numéros de révision sur la version du fichier, et pour la version finale, copier la version du fichier en cours à la version de montage. Le produit est en cours d'utilisation de la production, mais encore en développement - vous savez -. Une de ces petites entreprises, pas des situations d'infrastructure de contrôle des changements

La solution

Versioning est quelque chose que je suis très passionné et ai passé beaucoup de temps à essayer de trouver un outil facile à utiliser le système de versioning. D'après ce que vous avez déjà dit dans votre question, il est clair que vous avez compris un point important, les numéros de version de montage ne sont pas synonymes de la version du produit. L'un est entraîné sur le plan technique, et l'autre est entraîné par l'entreprise.

Ce qui suit suppose que vous utilisez une certaine forme de contrôle de code source et un serveur de build. Pour le contexte, nous utilisons TeamCity et Subversion / Git. TeamCity est gratuit pour un petit (10) le nombre de projets et est un serveur très bonne construction, mais il y a d'autres qui sont tout à fait gratuitement une partie de.

Quel numéro de version signifie

Qu'est-ce que un moyen de version à une personne peut signifier quelque chose de différent à l'autre, la structure générale est majeur, mineur, macro, micro. La façon dont je regarde un numéro de version est de décomposer en deux parties. La première moitié décrit la version principale (Major) et toutes les mises à jour clés (mineures). La seconde moitié indique quand il a été construit et que la version du code source était. numéros de version aussi des choses méchantes différentes en fonction du contexte, est-il une API, Web App, etc.

Major.Minor.Build.Revision

Ce Revision est le nombre pris de contrôle de code source pour identifier ce a été effectivement construit.
Ce Build est un nombre toujours croissant qui peut être utilisé pour trouver un construction particulière sur le serveur de build. Il est un nombre important parce que la serveur de build peut avoir construit le même la source à deux reprises avec un ensemble différent de paramètres. En utilisant le numéro de build dans conjointement avec le numéro de source vous permet d'identifier ce qui a été construit et comment.
Minor cela ne devrait changer quand il y a un changement important l'interface publique. Par exemple, si elle est API, coderez consommer encore être en mesure de compiler? Ce nombre doit être remis à zéro lorsque les changements de numéro majeur.
Major indique quelle version du produit vous vous trouvez. Par exemple, la Major de tous les VisualStudio 2008 ensembles est 9 et VisualStudio 2010 est de 10.

L'exception à la règle

Il y a toujours des exceptions à la règle et vous devrez adapter que vous tombez sur eux. Mon approche originale était basée sur l'utilisation de la subversion, mais récemment, je l'ai déplacé à Git. Source de contrôle comme la sécurité de la subversion et de la source qui utilisent un référentiel central ont un numéro qui peut être utilisé pour identifier un ensemble de sources d'un moment donné. Ce n'est pas le cas pour un contrôle de source distribué tels que Git. Parce que Git utilise des référentiels distribués qui sont sur chaque machine de développement il n'y a pas de numéro incrémenter automatique que vous pouvez utiliser, il y a un hack qui utilise le nombre de check-ins, mais il est laid. En raison de cela, j'ai dû évoluer mon approche.

Major.Minor.Macro.Build

Le numéro de révision est maintenant disparu, la construction a changé à l'endroit où la révision autrefois et Macro a été inséré. Vous pouvez utiliser la macro comment vous semble, mais la plupart du temps, je le laisser seul. Parce que nous utilisons TeamCity les informations perdues à partir du numéro de révision se trouve dans la construction, cela ne signifie qu'il ya un processus en deux étapes, mais nous avons rien perdu et est un compromis acceptable.

Que définir

La première chose à comprendre est que la version Assemblée, Version fichier et version du produit ne doit pas correspondre. Je ne préconise pas avoir différents ensembles de nombres, mais il rend la vie beaucoup plus facile lors de petits changements à une assemblée qui ne touche pas toutes les interfaces publiques que vous n'êtes pas obligé de recompiler assemblées dépendantes. I façon beaucoup avec ceci est seulement régler les numéros majeurs et mineurs à l'Assemblée Version mais de mettre toutes les valeurs dans la version de fichier. Par exemple:

1.2.0.0 (AssemblyVersion)
1.2.3.4 (FileVersion)

Cela vous donne la possibilité de déployer des correctifs qui ne cassera pas le code existant parce que les versions de montage ne correspondent pas, mais vous permettent de voir la révision / construction d'un ensemble en regardant son numéro de version du fichier. Ceci est une approche commune et peut être vu sur certains ensembles open source quand on regarde les détails de montage.

Vous en tant que chef d'équipe devrait être responsable pour incrémenter le numéro mineur si jamais un changement de rupture est nécessaire. Une solution à déployer un changement nécessaire à une interface, mais pas casser le code précédent est de marquer l'actuel comme obsolète et la création d'une nouvelle interface. Cela signifie que le code existant est averti que la méthode est obsolète et pourrait être retiré à tout moment, mais ne vous oblige pas à tout casser immédiatement. Vous pouvez ensuite supprimer la méthode obsolète quand tout a été migré.

Comment câbler ensemble

Vous pouvez faire tout ce qui précède manuellement, mais il serait très temps, ce qui suit est la façon dont nous automatisons le processus. Chaque étape est runnable.

Supprimer AssemblyVersion et AssemblyFileVersion attributs de tout projet AssemblyInfo fichiers .cs.
Créez un fichier d'information d'assemblage commun (appeler VersionInfo.cs) et l'ajouter comme un élément lié à tous vos projets.
Ajoutez les attributs de AssemblyVersion et AssemblyFileVersion à la version avec des valeurs de "0.0.0.0".
Créer un projet MsBuild qui construit votre fichier de solution.
Ajoutez dans une tâche avant la construction qui met à jour les VersionInfo.cs. Il y a un certain nombre de bibliothèques msbuild open source qui incluent une tâche AssemblyInfo qui peut régler le numéro de version. Il suffit de le mettre à un nombre arbitraire et test.
Ajouter un groupe immobilier contenant une propriété pour chacun des segments du numéro de build. C'est là que vous définissez le majeur et mineur. Le numéro de build et de révision devrait être adoptée comme arguments.

Avec la subversion:

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

Je espère avoir été clair, mais il y a beaucoup impliqué. S'il vous plaît poser toutes les questions. Je vais utiliser tous les commentaires pour mettre un billet de blog plus de concis ensemble.

Autres conseils

Le [AssemblyVersion] est une très grande dans .NET. Une philosophie, encouragée par Microsoft est que vous laissez l'auto-incrément, forçant tous projets qui dépendent de l'ensemble à recompiler. Works si vous utilisez peu près correct d'un serveur de build. Il est jamais mauvais chose à faire, mais méfiez-vous des personnes portant des épées.

L'autre, associé plus étroitement avec sa signification réelle est que le nombre est représentatif du versioning de l'interface publique de l'Assemblée. En d'autres termes, vous modifiez uniquement lorsque vous modifiez une interface publique ou une classe. Depuis que le changement d'une telle demande aux clients de l'ensemble à recompilé. Cela doit se faire manuellement si, le système de construction est pas assez intelligent pour détecter automatiquement un tel changement.

Vous pouvez encore étendre cette approche que par incrémenter la version lorsque l'ensemble a été déployé sur des machines hors de votre portée. Telle est l'approche qui utilise Microsoft, leurs ensembles .NET numéros de version changent très rarement. La plupart du temps en raison de la douleur considérable qu'elle provoque sur leurs clients.

Alors, que Microsoft prêche est pas ce qu'il pratique. Son processus de construction et de contrôle est cependant versioning sans précédent, ils ont même un ingénieur logiciel dédié qui surveille le processus. N'a pas travaillé tout à fait si bien, le WaitHandle.WaitOne (int) surcharge en particulier

Vous pouvez utiliser la partie de construction du numéro de version pour l'auto-incrément.

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

Dans votre environnement une version de test est une version qui a une version de build! = 0. A sa sortie d'incrémenter la partie mineure et définir la partie de construction à 0, voici comment vous identifier ensembles libérés.

Si vous installez vos assemblys dans le GAC votre GAC est inondé avec beaucoup de versions diffent au fil du temps, donc gardez cela à l'esprit. Mais si vous utilisez les dll que localement, je pense que cela est une bonne pratique.

Ajout à Bronumskis réponse , je tiens à souligner que, après la norme sémantique Versioning 2.0 semver.org , Major.Minor.Build.Revision serait illégale en raison de la règle selon laquelle, après l'augmentation d'un nombre, toutes les valeurs régulières à droite devraient être remis à zéro .

Une meilleure façon suivante la norme serait d'utiliser Major.Minor+Build.Revision. Ceci est obivously pas pour une utilisation dans AssemblyVersionAttribute, mais un attribut personnalisé ou une classe statique peut être utilisé à la place.

Semver à TeamCity devrait être disponible en utilisant le méta-coureur Power Pack. Pour git avec git-flux (en particulier dans le monde .NET), j'ai trouvé GitVersion pour être utile.

Il n'y a pas de règle stricte en ce qui concerne les assemblées versioning, donc ne hésitez pas à essayer qui jamais travailler pour vous, mais je vous suggère de faire usage de 4 parties l'approche que vous aurez la flexiblity Incase vous voulez faire quelques changements dans l'avenir.

... Ex:. * 1.0.0

Réservé - Cela ajoute flexiblity supplémentaire, Incase vous voulez faire un changement à l'avenir. Mais comme défaut, le garder comme 0.

En outre, envisager de signer l'assemblage avec la clé forte. Cela permettra de résoudre la question des conflits d'assemblage Incase vous avez la version multiple de montage enregistré dans le GAC. MSDN lien

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow