Puis-je incrémenter automatiquement la version de génération de fichier lors de l'utilisation de Visual Studio?
Je me demandais simplement comment je pouvais automatiquement incrémenter la construction (et la version?) De mes fichiers à l'aide de Visual Studio (2005).
Si je cherche les propriétés de say C:\Windows\notepad.exe, l'onglet Version donne "Version du fichier: 5.1.2600.2180". Je voudrais aussi obtenir ces chiffres intéressants dans la version de ma DLL, et non dans la version 1.0.0.0, qui est un peu ennuyeuse.
J'ai essayé quelques solutions, mais cela ne semble pas être une fonctionnalité prête à l'emploi ou je cherche peut-être simplement au mauvais endroit (comme d'habitude).
Je travaille principalement avec des projets web ....
J'ai regardé les deux:
- http://www.codeproject.com/KB/dotnet/Auto_Increment_Version.aspx
- http://www.codeproject.com/KB/dotnet/build_versioning.aspx
et je ne pouvais pas croire que tant d'efforts pour faire quelque chose soit une pratique courante.
EDIT: Cela ne fonctionne pas dans VS2005 pour autant que je sache ( http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx )
Dans Visual Studio 2008, les travaux suivants.
Recherchez le fichier AssemblyInfo.cs et recherchez ces 2 lignes:
[Assembly: AssemblyVersion("1.0.0.0")]
[Assembly: AssemblyFileVersion("1.0.0.0")]
Vous pouvez essayer de changer ceci en:
[Assembly: AssemblyVersion("1.0.*")]
[Assembly: AssemblyFileVersion("1.0.*")]
Mais cela ne vous donnera pas le résultat souhaité, vous obtiendrez une version du produit de 1.0. * et une version de fichier de 1.0.0.. Pas ce que tu veux!
Cependant, si vous supprimez la deuxième de ces lignes et n’avez que:
[Assembly: AssemblyVersion("1.0.*")]
Ensuite, le compilateur définira la version du fichier comme étant la version du produit et vous obtiendrez le résultat souhaité pour une version de produit et de fichier incrémentée automatiquement et synchronisée. Par exemple. 1.0.3266.92689
ouvrez le fichier AssemblyInfo.cs et changez
// 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 dans IDE en allant dans projet -> propriétés -> informations d'assemblage
Cependant, cela ne vous permettra que d’incrémenter automatiquement la version d’Assembly et vous donnera la
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.
Donc, ouvrez simplement assemblyinfo.cs et faites-le manuellement.
Une autre option pour modifier les numéros de version dans chaque version consiste à utiliser la tâche Version de MSBuild.Community.Tasks . Il suffit de télécharger leur programme d'installation, de l'installer, puis d'adapter le code suivant et de le coller après <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> dans votre fichier .csproj:
<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>
Remarque: Adaptez la propriété StartDate à vos paramètres régionaux. actuellement, il n’utilise pas 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 ont être retiré de AssemblyInfo.cs.
Les différents algorithmes permettant de modifier les composants de version sont décrits dans $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm et Propriétés de la version .
J'ai proposé une solution similaire à celle des chrétiens, mais sans dépendre des tâches de la communauté MSBuild, ce n'est pas une option pour moi car je ne souhaite pas installer ces tâches pour tous nos développeurs.
Je suis en train de générer du code, de le compiler dans un assembly et de vouloir 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 les numéros de construction chaque jour et rompt la compatibilité avec les assemblys qui utilisent un numéro de version plus ancien. Au lieu de cela, je veux avoir une AssemblyVersion codée en dur, mais une AssemblyFileVersion auto-incrémentée. J'ai accompli cela en spécifiant AssemblyVersion dans AssemblyInfo.cs et en générant un VersionInfo.cs dans MSBuild comme celui-ci,
<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>
Cela générera un fichier VersionInfo.cs avec un attribut Assembly pour AssemblyFileVersion, où la version suit le schéma de YY.MM.DD.TTTT avec la date de construction. Vous devez inclure ce fichier dans votre projet et le construire.
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.*")]
Également en note de bas de page, le troisième nombre est le nombre de jours écoulés depuis le 2/01/2000 et le quatrième nombre représente la moitié du nombre total de secondes de la journée. Donc, si vous compilez à minuit, cela devrait être zéro.
Il existe une extension de Visual Studio Automatic Versions qui prend en charge Visual Studio 2012, 2013, 2015 et 2017.
Captures d'écran 
La définition d'un * dans le numéro de version dans AssemblyInfo ou dans les propriétés du projet, comme décrit dans les autres publications, ne fonctionne pas avec toutes les versions de Visual Studio/.NET.
Après tout, cela n’a pas fonctionné dans VS 2005 (mais dans VS 2003 et VS 2008). Pour VS 2005, vous pouvez utiliser les éléments suivants: numéro de version et de révision de Auto Increment Visual Studio 2005 au moment de la compilation .
Sachez toutefois que la modification automatique du numéro de version n'est pas recommandée pour les assemblys avec 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 eux-mêmes modifient le numéro de version des assemblys .NET Framework uniquement en cas de modification des interfaces. (NB: je cherche toujours le lien dans MSDN où j'ai lu cela.)
Pour obtenir des informations incrémentantes (DateTime) dans la propriété AssemblyFileVersion qui présente l’avantage de ne pas rompre les dépendances.
En vous appuyant sur la solution de Boog (cela n’a pas fonctionné pour moi, peut-être à cause de VS2008?), Vous pouvez combiner un événement de pré-génération générant un fichier, ajoutant ce fichier (y compris ses propriétés de version), puis utilisant un moyen de lecture ces valeurs encore. C'est..
Pre-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
Incluez le fichier VersionInfo.cs résultant (sous-dossier Properties) dans votre projet.
Code pour récupérer la date (années en secondes):
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);
Pas très à l'aise .. aussi, je ne sais pas si cela crée beaucoup de reconstructions forcées (puisqu'un fichier change toujours).
Vous pouvez le rendre plus intelligent, par exemple, si vous ne mettez à jour le fichier VersionInfo.cs que toutes les quelques minutes/heures (en utilisant un fichier temporaire, puis en copiant/remplaçant le véritable VersionInfo.cs si une modification suffisamment importante est détectée). Je l'ai fait une fois assez bien.
Définissez le numéro de version sur "1.0. *" Et les deux derniers numéros seront automatiquement renseignés avec la date (dans quelques jours) et l'heure (une demi-seconde à partir de minuit).
Cake supporte les correctifs de fichiers AssemblyInfo. Avec le gâteau dans les mains, vous avez une infinité de façons d'implémenter l'incrémentation automatique des versions.
Voici un exemple simple d’incrémentation de la version du compilateur C #:
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);
});
Ici:
- Version - est la version de l'assembly. La meilleure pratique consiste à verrouiller le numéro de version principal et à laisser des zéros (comme "1.0.0.0").
- FileVersion - est la version du fichier Assembly.
Notez que vous pouvez corriger non seulement les versions mais ainsi que toutes les autres informations nécessaires .
C'est dans les propriétés de votre projet sous Publier
Aller au projet | Cliquez sur Propriétés, puis sur Informations sur l’assemblage, puis sur Version d’assemblage et insérez un * dans la dernière ou l’avant-dernière case (vous ne pouvez pas incrémenter automatiquement les composants Major ou Minor).
Comment obtenir la version {major}.{year}.1{date}.1{time}
Celui-ci est un peu expérimental, mais je l'aime bien. Inspiré par Jeff Atwood @ CodingHorror ( lien ).
Le numéro de version obtenu devient 1.2016.10709.11641 (ce qui signifie 2016-07-09 16:41), ce qui permet de
- pauvre mans zéro padding (avec la stupide tête
1s) - lisible de manière presque humaine local DateTime intégré au numéro de version
- laissant la version majeure seule pour des changements vraiment majeurs.
Ajoutez un nouvel élément à votre projet, sélectionnez Général -> Modèle de texte, appelez-le ainsi: CustomVersionNumber et, le cas échéant, mettez en commentaire les AssemblyVersion et AssemblyFileVersion dans Properties/AssemblyInfo.cs.
Ensuite, lors de l’enregistrement de ce fichier ou de la construction du projet, cela régénérera un fichier .cs situé en tant que sous-élément sous le fichier créé .tt.
<#@ 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}" #>")]
A partir de maintenant, pour ma candidature,
string ver = Application.ProductVersion;
retourne ver = 1.0.3251.27860
La valeur 3251 est le nombre de jours depuis le 1/1/2000. Je l'utilise pour mettre une date de création de version sur l'écran de démarrage de mon application. Lorsque je traite avec un utilisateur, je peux demander la date de création, qui est plus facile à communiquer que celle d’un nombre long.
(Je ne travaille que par un seul homme et je soutiens une petite entreprise. Cette approche risque de ne pas fonctionner pour vous.)
Utilisez la tâche AssemblyInfo du projet de tâches de la communauté MSBuild ( http://msbuildtasks.tigris.org/ ) et intégrez-la dans votre fichier .csproj/.vbproj.
Il existe un certain nombre d'options, notamment une permettant d'associer le numéro de version à la date et à l'heure.
Conseillé.
La modification de AssemblyInfo fonctionne dans VS2012. Il semble étrange qu'il n'y ait plus de support pour cela dans Visual Studio, on pourrait penser que cela faisait partie du processus de construction/publication.
AssemblyInfoUtil . Libre. Open source.
Peut-être qu'il est trop tard pour répondre ici, mais espérons que cela résoudra le problème trépidant de quelqu'un.
Méthode automatique pour modifier la version d'assemblage de tous vos projets à l'aide du script PowerShell. Cet article va résoudre beaucoup de vos problèmes.
J'utilise cette approche https://stackoverflow.com/a/827209/3975786 en plaçant le modèle T4 dans un "Éléments de solution" et en l'utilisant avec "Ajouter en tant que lien" dans chaque projet.
Peut-être que, pour cette tâche, vous pouvez utiliser un 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);
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;
}
et appelez-le depuis le chargement du formulaire.
Avec ce code, vous pouvez mettre à jour n’importe quelle partie des informations sur le fichier dans AssemblyInfo.cs (mais vous devez utiliser une structure de répertoire "standard").
J'ai créé une application pour incrémenter automatiquement la version du fichier.
- Télécharger Application
ajoute la ligne suivante à la ligne de commande de l'événement pré-construit
C:\temp\IncrementFileVersion.exe $ (SolutionDir)\Properties\AssemblyInfo.cs
Construire le projet
Pour rester simple, l'application envoie uniquement des messages en cas d'erreur. Pour confirmer que tout fonctionne bien, vous devez vérifier la version du fichier dans 'Informations sur l'assemblage'.
Remarque: vous devrez recharger la solution dans Visual studio pour que le bouton 'Informations sur l'assemblage' remplisse les champs. Toutefois, votre fichier de sortie contiendra la version mise à jour.
Pour des suggestions et des demandes s'il vous plaît écrivez-moi à [email protected]
Chaque fois que je fais une construction, elle incrémente automatiquement le chiffre le moins significatif.
Je ne sais pas comment mettre à jour les autres, mais vous devriez au moins le voir déjà ...
Dans Visual Studio 2019
Ce n’était pas suffisant pour moi d’ajouter
[Assembly: AssemblyVersion("1.0.*")]
Lors de la construction, jette cette erreur
La chaîne de version spécifiée n'est pas conforme au format requis
Solution
Le format a finalement été accepté après avoir défini Deterministic sur False dans project.csproj
<Deterministic>false</Deterministic>
Modifier:
Pour une raison quelconque, régler Deterministic sur False a gâché mon fichier de configuration en le chargeant et en le sauvegardant à différents emplacements.
Solution de contournement:
J'ai configuré un événement post-build pour incrémenter le numéro de révision:
Script de lot pour l'événement post-construction
Ceci appelle un script powershell nommé autoincrement_version.ps1 en passant en argument le chemin de AssemblyInfo.cs.
if $(ConfigurationName) == Release (
PowerShell -ExecutionPolicy RemoteSigned $(ProjectDir)autoincrement_version.ps1 '$(ProjectDir)My Project\AssemblyInfo.cs'
)
Script Poweshell
Il auto-incrémente le numéro de révision en utilisant 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