Comment puis-je incrémenter automatiquement la version d'assemblage C # via notre plate-forme CI (Hudson)?

Question

Moi et mon groupe sont horribles à l'incrémentation des numéros de version d'assembly et nous envoient fréquemment des assemblages avec 1.0.0.0 versions. Évidemment, cela provoque beaucoup de maux de tête.

Nous sommes beaucoup mieux avec nos pratiques par le biais de notre IC plate-forme et j'ai vraiment envie de le configurer pour auto incrémente les valeurs au sein de l' assemblyinfo.cs le fichier de sorte que les versions de nos assemblées sont automatiquement mis à jour avec les modifications de code dans cette assemblée.

J'avais déjà de l'installation (avant nous avons trouvé Hudson) permet d'incrémenter la valeur par le biais soit d' msbuild ou de la ligne de commande (ne me souviens pas), mais avec d'Hudson, qui permettra de mettre à jour le référentiel SVN et de déclencher une AUTRE build. Qui seraient le résultat d'une lente boucle infinie comme Hudson sondages SVN toutes les heures.

Est d'avoir Hudson incrémenter le numéro de version une mauvaise idée? Ce serait une autre façon de faire?

Idéalement, mes critères pour une solution consisterait à:

• Incrémente le numéro de version en assemblyinfo.cs avant de construire
• Seulement incrémente le numéro de version dans les assemblées qui ont changé. Cela peut ne pas être possible d'Hudson efface le dossier du projet à chaque fois qu'il fait construire
• Engage la changé assemblyinfo.cs dans le dépôt de code (actuellement VisualSVN)
• Ne cause pas d'Hudson pour déclencher une nouvelle construction, la prochaine fois il analyse les changements

De travail dans ma tête, je pourrais facilement trouver une solution à la plupart de ce par le biais de fichiers de commandes / commandes, mais toutes mes idées serait la cause d'Hudson pour déclencher une nouvelle version lors de l'analyse suivante. Je ne suis pas à la recherche de quelqu'un de tout faire pour moi, il suffit de me pointer dans la bonne direction, peut-être une technique pour obtenir de l'Hudson à ignorer certains commits SVN, etc.

Tout ce que j'ai trouvé pour l'instant est juste un article expliquant comment obtenir le numéro de version incrémenté automatiquement, rien ne tient compte de l'IC plate-forme qui pourrait être tourné dans une boucle infinie.

Answer 1

Voici ce que j'ai fait, pour le marquage de l'AssemblyFileVersion attribut.

Enlevé le AssemblyFileVersion de AssemblyInfo.cs

Ajouter un nouveau, vide, fichier appelé AssemblyFileInfo.cs pour le projet.

Installer le MSBuild missions de la communauté de http://msbuildtasks.tigris.org/ sur l'hudson construire la machine.

Modifier le projet (csproj) de fichiers , c'est juste un fichier msbuild, et d'ajouter la suivante.

Quelque part, il y a un <PropertyGroup> indiquant la version. Changement afin qu'il lit par exemple

 <Major>1</Major>
 <Minor>0</Minor>
 <!--Hudson sets BUILD_NUMBER and SVN_REVISION -->
 <Build>$(BUILD_NUMBER)</Build>
 <Revision>$(SVN_REVISION)</Revision>

Hudson donne à ceux des variables d'environnement que vous voyez lorsque le projet est construit sur hudson (en supposant que c'est récupérée à partir de la subversion).

Au bas du fichier de projet, ajouter

 <Import Project="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets" Condition="Exists('$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets')" />
  <Target Name="BeforeBuild" Condition="Exists('$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets')">
    <Message Text="Version: $(Major).$(Minor).$(Build).$(Revision)" />
    <AssemblyInfo CodeLanguage="CS" OutputFile="AssemblyFileInfo.cs" AssemblyFileVersion="$(Major).$(Minor).$(Build).$(Revision)" AssemblyConfiguration="$(Configuration)" Condition="$(Revision) != '' " />
  </Target>

Il utilise la MSBuildCommunityTasks pour générer le AssemblyFileVersion.cs pour inclure une AssemblyFileVersion attribut avant que le projet est construit. Vous pouvez faire cela pour toutes les/tous les attributs version si vous le souhaitez.

Le résultat est, lors de l'émission d'hudson construire, le montage devient un AssemblyFileVersion de 1.0.HUDSON_BUILD_NR.SVN_REVISION par exemple 1.0.6.2632 , ce qui signifie que la 6 ième build # à hudson, dans le buit de la révision subversion 2632.

Answer 2

Une alternative simple consiste à laisser l'environnement C # incrémenter la version de l'assembly en définissant l'attribut de version sur major.minor.* (comme décrit dans le modèle de fichier AssemblyInfo.)

Cependant, vous cherchez peut-être une solution plus complète.

EDIT (réponse à la question dans un commentaire):

De AssemblyInfo.cs :

 // Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// 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.*")]
 

Answer 3

Voici une solution élégante qui nécessite un peu de travail initial lors de l'ajout d'un nouveau projet, mais prend en charge le processus très facilement.

L'idée est que chaque projet liens vers un fichier de Solution qui ne contient que la version de l'assembly de l'information. Si votre processus de création n'a qu'à mettre à jour un fichier unique et toutes les versions de montage tirer à partir d'un fichier lors de la compilation.

Étapes:

1. Ajouter une classe pour vous solution le fichier *.cs fichier, j'ai nommé min SharedAssemblyProperties.cs
2. Supprimer la totalité de la cs de l'information à partir de ce nouveau fichier
3. Couper l'assemblée de l'information à partir d'un fichier AssemblyInfo: [assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")]
4. Ajouter l'instruction "à l'aide du Système.La réflexion;" le fichier, puis coller les données dans votre nouveau fichier (ex SharedAssemblyProperties.cs)
5. Ajouter un élément existant à vous de projet (attendre... lire la suite avant d'ajouter le fichier)
6. Sélectionnez le fichier et avant que vous cliquez sur Ajouter, cliquez sur la liste déroulante à côté du bouton ajouter et sélectionnez "Ajouter un Lien".
7. Répétez les étapes 5 et 6 pour tous les projets actuels et nouveaux dans la solution

Lorsque vous ajoutez le fichier en tant que lien, il stocke les données dans le fichier de projet et lors de la compilation tire à l'assemblée informations sur la version de ce fichier.

À vous de contrôle à la source, vous ajoutez un fichier bat ou fichier de script simplement incrémente le SharedAssemblyProperties.cs fichier et l'ensemble de vos projets de mise à jour de leur assemblée informations de ce fichier.

Answer 4

Hudson peut être configuré pour ignorer les modifications apportées à certains chemins et les fichiers de sorte qu'il ne demande pas une nouvelle construction.

Sur la page de configuration de travail, en vertu de Gestion du Code Source, cliquez sur l' Avancée de bouton. Dans les Régions Exclues , vous saisissez un ou plusieurs expression régulière correspondant à des exclusions.

Par exemple, pour ignorer les modifications apportées à la version.les propriétés de fichier, vous pouvez utiliser:

/MyProject/trunk/version.properties

Cela fonctionne pour d'autres langues que le C# et vous permet de stocker vos informations de version dans la subversion.

Answer 5

NET le fait pour vous. Dans votre fichier AssemblyInfo.cs, définissez la version de votre assemblage sur major.minor. * (Par exemple: 1.0. *).

Lorsque vous construisez votre projet, la version est générée automatiquement.

Les numéros de build et de révision sont générés en fonction de la date, en utilisant l’époque unix, je crois. La génération est basée sur le jour actuel et la révision sur le nombre de secondes écoulées depuis minuit.