Puis-je incrémenter automatiquement la version du fichier lors de l’utilisation de Visual Studio?

Je me demandais comment augmenter automatiquement la version (et la version?) De mes fichiers à l’aide de Visual Studio (2005).

Si je recherche les propriétés de disons C:\Windows\notepad.exe , l’onglet Version indique “Version du fichier: 5.1.2600.2180”. Je voudrais aussi avoir ces chiffres sympas dans la version de mon dll, pas la version 1.0.0.0, qui est un peu ennuyeuse.

J’ai essayé plusieurs choses, mais cela ne semble pas être une fonctionnalité prête à l’emploi, ou peut-être que je ne regarde pas au bon endroit (comme d’habitude).

Je travaille principalement avec des projets web ….

J’ai regardé les deux:

  1. http://www.codeproject.com/KB/dotnet/Auto_Increment_Version.aspx
  2. http://www.codeproject.com/KB/dotnet/build_versioning.aspx

et je ne pouvais pas y croire tant d’efforts pour faire quelque chose est la pratique standard.

EDIT: Il ne fonctionne pas dans VS2005 autant que je puisse le dire ( http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx )

Dans Visual Studio 2008, les travaux suivants

Recherchez le fichier AssemblyInfo.cs et trouvez ces 2 lignes:

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

Vous pouvez essayer de changer ceci pour:

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

Mais cela ne vous donnera pas le résultat souhaité, vous vous retrouverez avec une version de produit de 1.0. * Et une version de fichier de 1.0.0.0 . Pas ce que tu veux!

Cependant, si vous supprimez la seconde de ces lignes et que vous avez juste:

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

Ensuite, le compilateur définira la version du fichier comme étant identique à la version du produit et vous obtiendrez le résultat souhaité d’une version automatiquement incrémentée du produit et du fichier qui sont synchronisés. Par exemple 1.0.3266.92689

ouvrez le fichier AssemblyInfo.cs et modifiez

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

vous pouvez le faire en IDE en allant dans le projet -> propriétés -> informations d’assemblage

Cela ne vous permettra cependant que d’incrémenter automatiquement la version de l’assemblage et vous donnera le

Version du fichier d’assemblage: Un caractère générique (“*”) n’est pas autorisé dans ce champ

message si vous essayez de placer un * dans le champ de version du fichier.

Il suffit donc d’ouvrir le assemblyinfo.cs et le faire manuellement.

Une autre option pour modifier les numéros de version dans chaque version consiste à utiliser la tâche Version de MSBuild.Community.Tasks . Téléchargez simplement leur programme d’installation, installez-le, puis adaptez le code suivant et collez-le après dans votre fichier .csproj :

           

Remarque: Adaptez la propriété StartDate à vos parameters régionaux. Il n’utilise pas actuellement la culture invariante.

Pour la troisième version du 14 janvier 2010, cela crée un VersionInfo.cs avec ce contenu:

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

Ce fichier doit ensuite être ajouté au projet (via Ajouter un élément existant ) et les lignes AssemblyVersion et AssemblyFileVersion doivent être supprimées de AssemblyInfo.cs .

Les différents algorithmes de modification des composants de la version sont décrits dans $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm et les propriétés de la version .

Je suis arrivé avec une solution similaire aux chrétiens mais sans dépendre des tâches communautaires de MSBuild, ce n’est pas une option pour moi car je ne veux pas installer ces tâches pour tous nos développeurs.

Je suis en train de générer du code et de comstackr dans un assemblage et je veux incrémenter automatiquement les numéros de version. Cependant, je ne peux pas utiliser l’astuce VS 6.0. * AssemblyVersion car elle incrémente automatiquement chaque jour les numéros de build et rompt la compatibilité avec les assemblys qui utilisent un ancien numéro de build. Au lieu de cela, je veux avoir un AssemblyVersion codé en dur, mais un AssemblyFileVersion auto-incrémenté. Je l’ai fait en spécifiant AssemblyVersion dans le fichier AssemblyInfo.cs et en générant un fichier VersionInfo.cs dans MSBuild comme ceci,

   $([System.DateTime]::Now.ToSsortingng("yy")) $([System.DateTime]::Now.ToSsortingng("MM")) $([System.DateTime]::Now.ToSsortingng("dd"))  [assembly:System.Reflection.AssemblyFileVersion("$(Year).$(Month).$(Date).$(Time)")]      

Cela générera un fichier VersionInfo.cs avec un atsortingbut Assembly pour AssemblyFileVersion où la version suit le schéma de YY.MM.DD.TTTT avec la date de génération. Vous devez inclure ce fichier dans votre projet et le comstackr.

Installez le complément Build Version Increment . Cela vous donne beaucoup plus de contrôle que l’option *.

Pour obtenir les numéros de version, essayez

  System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly(); System.Reflection.AssemblyName assemblyName = assembly.GetName(); Version version = assemblyName.Version; 

Pour définir le numéro de version, créez / modifiez AssemblyInfo.cs

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

En outre, le troisième nombre correspond au nombre de jours écoulés depuis le 2/1/2000 et le quasortingème nombre correspond à la moitié du nombre total de secondes de la journée. Donc, si vous comstackz à minuit, cela devrait être zéro.

La définition d’un * dans le numéro de version dans AssemblyInfo ou sous les propriétés du projet, comme décrit dans les autres publications, ne fonctionne pas avec toutes les versions de Visual Studio / .NET.

Afaik il n’a pas fonctionné dans VS 2005 (mais dans VS 2003 et VS 2008). Pour VS 2005, vous pouvez utiliser les éléments suivants: Incrémentation automatique de la version de Visual Studio 2005 et numéro de révision au moment de la compilation .

Mais sachez que la modification automatique du numéro de version n’est pas recommandée pour les assemblys avec un nom fort. La raison en est que toutes les références à un tel assembly doivent être mises à jour chaque fois que l’assembly référencé est reconstruit car les références d’assembly avec nom fort sont toujours une référence à une version d’assembly spécifique. Microsoft lui-même modifie le numéro de version des assemblys .NET Framework uniquement s’il existe des modifications dans les interfaces. (NB: je cherche toujours le lien dans MSDN où je lis ça.)

Définissez le numéro de version sur “1.0. *” Et il remplira automatiquement les deux derniers chiffres avec la date (en jours à partir d’un certain point) et l’heure (la moitié des secondes à partir de minuit)

Pour obtenir des informations incrémentées (DateTime) dans la propriété AssemblyFileVersion qui présente l’avantage de ne rompre aucune dépendance.


S’appuyant sur la solution de Boog (ne fonctionnait pas pour moi, peut-être à cause de VS2008?), Vous pouvez combiner un événement de pré-génération générant un fichier, en ajoutant ce fichier (y compris ses propriétés de version), puis en utilisant un moyen de lecture. ces valeurs à nouveau. C’est..

Pré-Build-Event:

 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 

Inclure le fichier VersionInfo.cs résultant (sous-dossier Propriétés) dans votre projet

Code pour récupérer la date (années en secondes):

 var version = assembly.GetName().Version; var fileVersionSsortingng = System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location).FileVersion; Version fileVersion = new Version(fileVersionSsortingng); var buildDateTime = new DateTime(fileVersion.Major, fileVersion.Minor/100, fileVersion.Minor%100, fileVersion.Build/100, fileVersion.Build%100, fileVersion.Revision); 

Pas très confortable .. aussi, je ne sais pas si cela crée beaucoup de force-reconstruit (car un fichier change toujours).

Vous pourriez par exemple le rendre plus intelligent si vous ne mettez à jour que le fichier VersionInfo.cs toutes les quelques minutes / heures (en utilisant un fichier temporaire, puis en copiant / écrasant le fichier VersionInfo.cs réel si un changement suffisamment important est détecté). Je l’ai fait une fois avec succès.

Il existe une extension de studio visuel Automatic Versions qui prend en charge Visual Studio 2012, 2013, 2015 & 2017.

Captures d’écran entrer la description de l'image ici

entrer la description de l'image ici

Il est dans les propriétés de votre projet sous Publier

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

Cake prend en charge l’assignation de fichiers AssemblyInfo. Avec le gâteau en mains, vous disposez de moyens infinis pour implémenter l’incrémentation automatique de la version.

Un exemple simple de version incrémentée comme le compilateur C # fait:

 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 = ssortingng.Format("3.0.{0}.{1}", daysPart, secondsPart) }; CreateAssemblyInfo("MyProject/Properties/AssemblyInfo.cs", assemblyInfo); }); 

Ici:

  • Version – est la version d’assemblage. La meilleure pratique consiste à verrouiller le numéro de version majeur et à laisser des zéros (comme “1.0.0.0”).
  • FileVersion – est la version du fichier d’assemblage.

Notez que vous pouvez non seulement patcher les versions mais aussi toutes les autres informations nécessaires .

Aller au projet | Propriétés, puis informations d’assemblage, puis version d’assemblage et mettre un * dans la dernière ou dernière case (vous ne pouvez pas incrémenter automatiquement les composants majeurs ou mineurs).

Utilisez la tâche AssemblyInfo du projet MSBuild Community Tasks ( http://msbuildtasks.tigris.org/ ) et intégrez-la dans votre fichier .csproj / .vbproj.

Il dispose d’un certain nombre d’options, dont une pour associer le numéro de version à la date et à l’heure du jour.

Conseillé.

En ce moment, pour ma demande,

 ssortingng ver = Application.ProductVersion; 

renvoie ver = 1.0.3251.27860

La valeur 3251 correspond au nombre de jours écoulés depuis le 1/1/2000. Je l’utilise pour mettre une date de création de version sur l’écran d’accueil de mon application. Lorsque je traite avec un utilisateur, je peux demander la date de création qui est plus facile à communiquer que certains numéros longs.

(Je suis un homme seul soutenant une petite entreprise. Cette approche peut ne pas fonctionner pour vous.)

La modification de AssemblyInfo fonctionne dans VS2012. Il semble étrange qu’il n’y ait pas plus de support pour cela dans Visual Studio, vous penseriez que c’était une partie essentielle du processus de construction / publication.

Comment obtenir la version {major}.{year}.1{date}.1{time}

Celui-ci est en quelque sorte expérimental, mais je l’aime bien. Inspiré par Jeff Atwood @ CodingHorror ( lien ).

Le numéro de version résultant devient 1.2016.10709.11641 (ce qui signifie 2016-07-09 16:41), ce qui permet de

  • pauvre homme zéro rembourrage (avec le premier imbécile)
  • quasi-humain lisible DateTime locale incorporé dans le numéro de version
  • laissant la version principale seule pour des changements de rupture vraiment importants.

Ajoutez un nouvel élément à votre projet, sélectionnez Général -> Modèle de texte, nommez-le quelque chose comme CustomVersionNumber et (le cas échéant) CustomVersionNumber commentaire AssemblyVersion et AssemblyFileVersion dans Properties/AssemblyInfo.cs .

Ensuite, lors de l’enregistrement de ce fichier ou de la création du projet, cela régénérera un fichier .cs situé en tant que sous-élément sous le fichier .tt créé.

 < #@ 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}" #>")] 

Peut-être que pour cette tâche, vous pouvez utiliser du code comme celui-ci:

  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); ssortingng ol = ve.FileMajorPart.ToSsortingng() + "." + ve.FileMinorPart.ToSsortingng() + "." + ve.FileBuildPart.ToSsortingng() + "." + ve.FilePrivatePart.ToSsortingng(); ssortingng ne = ve.FileMajorPart.ToSsortingng() + "." + ve.FileMinorPart.ToSsortingng() + "." + (ve.FileBuildPart + 1).ToSsortingng() + "." + ve.FilePrivatePart.ToSsortingng(); 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; } 

et appelez-le depuis le chargement de formulaire.
Avec ce code, vous pouvez mettre à jour toute partie des informations de fichier dans AssemblyInfo.cs (mais vous devez utiliser la structure de répertoires “standard”).

AssemblyInfoUtil . Gratuit. Open source.

J’utilise cette approche https://stackoverflow.com/a/827209/3975786 en plaçant le modèle T4 dans un «élément de solution» et en l’utilisant avec «Ajouter en tant que lien» dans chaque projet.

Peut-être qu’il est trop tard pour répondre ici, mais j’espère que cela va résoudre le problème mouvementé de quelqu’un.

Un moyen automatique de modifier la version de l’assembly de tous vos projets à l’aide du script PowerShell. Cet article résoudra plusieurs de vos problèmes.

Chaque fois que je fais un build, il incrémente automatiquement le chiffre le moins significatif.

Je n’ai aucune idée de la façon de mettre à jour les autres, mais vous devriez au moins voir cela déjà …

J’ai créé une application pour incrémenter automatiquement la version du fichier.

  1. Télécharger l’ application
  2. Ajoutez la ligne suivante à la ligne de commande d’événement de pré-génération

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

  3. Construire le projet

Pour garder les choses simples, l’application envoie uniquement des messages en cas d’erreur. Pour confirmer que cela fonctionne correctement, vous devez vérifier la version du fichier dans la section «Informations sur l’assemblage».

Remarque: vous devrez recharger la solution dans Visual Studio pour le bouton «Informations d’assemblage» afin de remplir les champs. Cependant, votre fichier de sortie aura la version mise à jour.

Pour des suggestions et des demandes s’il vous plaît écrivez-moi à telson_alva@yahoo.com