Puis-je incrémenter automatiquement la version de génération de fichier lors de l'utilisation de Visual Studio?

Question

Je me demandais comment je pourrais automatiquement incrémenter la construction (et la version?) De mes fichiers en utilisant Visual Studio (2005).

Si je consulte les propriétés de dis 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 dans la version 1.0.0.0, ce qui est un peu ennuyeux.

J'ai essayé quelques petites choses, mais cela ne semble pas être une fonctionnalité prête à l'emploi, ou peut-être que je cherche juste au mauvais endroit (comme d'habitude).

Je travaille avec principalement 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 le croire tant d'efforts faire quelque chose est une pratique courante.

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

Answer 1

Dans Visual Studio 2008, les travaux suivants.

Trouver le fichier AssemblyInfo.cs et trouver ces 2 lignes:

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

Vous pouvez essayer de changer cela:

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

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

Toutefois, si vous supprimez la seconde de ces lignes et juste:

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

le compilateur tournerai la version du fichier égale à la version du produit et vous obtiendrez le résultat souhaité d'un automatique incrémenter le produit et la version du fichier qui sont synchronisés. Par exemple. 1.0.3266.92689

Answer 2

Chaque fois que je fais construire il incrémente automatiquement le moins significatif chiffres.

Je n'ai aucune idée comment mettre à jour les autres, mais vous devriez au moins rencontrerai déjà ...

Answer 3

Aller au projet | Propriétés, puis Informations d'assemblage, puis Version de l'assemblage et placez un * dans le dernier ou l'avant-dernier champ (vous ne pouvez pas incrémenter automatiquement les composants majeurs ou mineurs).

Answer 4

Pour obtenir les numéros de version tentent

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éer/modifier AssemblyInfo.cs

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

également comme une note de côté, le troisième numéro est le nombre de jours depuis le 2/1/2000 et le quatrième nombre est la moitié du nombre total de secondes dans la journée. Donc, si vous compilez à minuit, cela devrait être zéro.

Answer 5

ouvrir le AssemblyInfo.fichier cs et changer

// 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 du projet -> propriétés -> Informations de montage

Cependant, cela ne vous permettra d'incrémentation automatique du La version d'assemblage et vous donnera le

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

boîte de message si vous essayez de placer un * dans le champ de la version du fichier.

Alors, ouvrez simplement assemblyinfo.cs et faites-le manuellement.

Answer 6

Définissez le numéro de version « 1.0. * » Et il remplira automatiquement les deux dernières avec la date (en jours d'un point) et le temps (la moitié des secondes de minuit)

Answer 7

Il est dans vos propriétés du projet sous Publish

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

Answer 8

Définition d'un * dans le numéro de version dans AssemblyInfo ou sous pro Les propriétés ject décrites dans les autres publications ne fonctionnent pas avec toutes les versions de Visual Studio/.NET. Afaik cela ne fonctionnait pas dans VS 2005 (mais dans VS 2003 et VS 2008). Pour VS 2005, vous pouvez utiliser les éléments suivants: Auto Increment Visual Studio 2005 version build and revision number on compile time. Mais sachez que le changement automatique du numéro de version n'est pas recommandé pour les assemblages à 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 en raison du fait que les références d'assembly à 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 s'il y a des changements dans les interfaces. (NB: je suis toujours à la recherche du lien dans MSDN où j'ai lu cela.)

Answer 9

En ce moment, pour mon application,

string ver = Application.ProductVersion; 

retours ver = 1.0.3251.27860

La valeur 3251 est le 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 de démarrage de mon application. En traitant avec un utilisateur, je peux demander la date de création qui est plus facile à communiquer qu'un certain nombre long.

(Je suis un département d'un homme soutenant une petite entreprise. Cette approche ne fonctionne pas pour vous.)

Answer 10

Utilisez la tâche AssemblyInfo du projet Tâches communautaires MSBuild (http://msbuildtasks.tigris.org/), et l'intégrer dans votre Fichier .csproj/.vbproj.

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

Recommandé.

Answer 11

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

Answer 12

Une autre option pour modifier les numéros de version dans chaque génération consiste à utiliser la tâche version de MSBuild.Community.Tasks. Il suffit de télécharger leur programme d'installation, l'installer, puis adapter le code suivant et 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> 

Note: Adapt la propriété StartDate à vos paramètres régionaux. It currently does not use the invariant culture.

Pour la troisième version le 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 alors ê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 permettant de modifier les composants de la version sont décrits dans $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm et . Propriétés de la version.

Answer 13

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

Je génère du code et compile dans un assemblage et souhaite incrémenter automatiquement les numéros de version. Cependant, je ne peux pas utiliser VS 6.0.* Astuce AssemblyVersion car elle incrémente automatiquement les numéros de build chaque jour et rompt la compatibilité avec les assemblys qui utilisent un ancien numéro de build. Au lieu de cela, je veux avoir une AssemblyVersion codée en dur mais une AssemblyFileVersion auto-incrémentée. Je l'ai accompli en spécifiant AssemblyVersion dans les AssemblyInfo.cs et la génération d'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 va générer un fichier VersionInfo.cs avec un attribut de montage pour AssemblyFileVersion où la version suit la schéma de YY.MM.DD.TTTT avec la date de construction. Vous devez inclure ce fichier dans votre projet et le construire avec lui.

Answer 14

Pour obtenir l'incrémentation des informations (DateTime) dans la propriété AssemblyFileVersion, ce qui présente l'avantage de ne pas interrompre les dépendances.

---

bâtiment

sur la solution de Boog (ne fonctionne pas pour moi, peut-être à cause de VS2008?), Vous pouvez utiliser une combinaison d'un événement pré-construction générer un fichier, ajoutant que le fichier (y compris ses propriétés de version) et puis en utilisant un moyen de relire ces valeurs à nouveau. C'est ..

Pre-Build-événement:

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 (Propriétés sous-dossier) dans votre projet

code pour obtenir date de retour (années vers le bas à quelques 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 confortable .. aussi, je ne sais pas si cela crée beaucoup de force les reconstructions (depuis 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/écrasant le vrai VersionInfo.cs si un changement assez important est détecté). Je l'ai fait une fois avec succès.

Answer 15

Peut-être, pour cette tâche, vous pouvez utiliser le code comme ceci:

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 l'appeler de la forme de chargement.
Avec ce code, vous pouvez mettre à jour n'importe quelle partie de l'information de fichier dans AssemblyInfo.cs (mais vous devez utiliser la structure de répertoire "standard").

Answer 16

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 fondamentale du processus de construction/publication.

Answer 17

AssemblyInfoUtil. Gratuit. Open source.

Answer 18

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 comme lien" dans chaque projet.

Answer 19

Cake prend en charge les correctifs de fichiers AssemblyInfo. Avec le gâteau dans les mains, vous avez des moyens infinis d'implémenter l'incrémentation automatique des versions.

exemple simple de la version incrémenter comme compilateur C# ne:

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 une version de montage. La meilleure pratique consiste à verrouiller le numéro de version principal et à laisser le reste avec des zéros (comme "1.0.0.0"). FileVersion - est la version du fichier d'assemblage.

Notez que vous pouvez patcher non seulement les versions mais also all other necessary information.

Answer 20

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

Celui-ci est un peu expérimental, mais je l'aime. Inspiré par Jeff Atwood @ CodingHorror (link).

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

• pauvres mans zéro padding (avec les plus grands 1 s stupides)
• lisible presque humain local DateTime incorporé dans le numéro de version
• laissant la version Major seule pour des changements de rupture très importants.

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

Ensuite, lors de l'enregistrement de ce fichier ou de la construction du projet, le fichier .cs situé sous le sous-élément .tt sera régénéré.

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

Answer 21

Peut-être qu'il est trop tard pour répondre ici mais espérons que cela va résoudre le problème trépidant de quelqu'un.

Un moyen automatique de changer la version d'assemblage de tous vos projets en utilisant le script PowerShell. This article va résoudre beaucoup de vos problèmes.

Answer 22

Il y a une extension de Visual Studio Automatic Versions qui prend en charge Visual Studio 2012, 2013, 2015 & 2017.

Captures d'écran

Answer 23

J'ai créé une application pour augmenter la version du fichier automatiquement.

1. Télécharger Application

2. ajoutez la ligne suivante de pré-construction ligne de commande d'événement

   C: \ temp \ IncrementFileVersion.exe $ (SolutionDir) \ Propriétés \ AssemblyInfo.cs

3. Construire le projet

Pour rester simple, l'application ne lance que des messages i f il y a une erreur, pour confirmer que cela a bien fonctionné, vous devrez vérifier la version du fichier dans 'Assembly Information'

Note: Vous devrez recharger la solution dans Visual Studio pour le bouton 'Assembly Information' pour remplir les champs , cependant votre fichier de sortie aura la version mise à jour.

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

Answer 24

Dans .NET, les informations de version pour un montage suit format suivant - [.. .].

Ce format de version se composent de quatre valeurs:

Major Version 
Minor Version 
Build Number 
Revision 

Au-dessus de quatre valeur peut être utilisée pour indiquer des choses différentes selon la façon dont vous voulez qu'ils soient compris.

Lorsque nous compilons ou construisons notre code dans .NET (en utilisant Visual Studio), il produit des ensembles et cet ensemble peut être étiqueté avec trois différents types de versions, qui sont les suivants:

Assembly Version 
Assembly File Version 
Assembly Informational Version 

Maintenant, nous allons prenez une minute pour comprendre ce que sont ces derniers et comment ou dans quel contexte sont-ils utilisés.

Try this solution with video click here

wild card