Puis-je incrémenter automatiquement la version de compilation du fichier en utilisant Visual Studio?

je me demandais juste comment je pouvais automatiquement incrémenter la construction (et la version?) de mes fichiers en utilisant Visual Studio (2005).

si je regarde les propriétés de say C:\Windows\notepad.exe , l'onglet Version donne"Version fichier: 5.1.2600.2180". Je voudrais obtenir ces cool numéros dans la version de ma dll est trop, pas la version 1.0.0.0, qui avouons-le est un peu terne.

j'ai essayé quelques petites choses, mais il ne semble pas être fonctionnalité "out-of-box", ou peut-être que je regarde juste au mauvais 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 croyez que tant d'efforts pour faire quelque chose est pratique courante.

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

320
demandé sur pb2q 2008-12-10 18:51:05
la source

23 ответов

Dans visual Studio 2008, les travaux suivants.

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

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

vous pourriez essayer de changer ceci en:

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

mais cela ne vous donnera pas le résultat souhaité, vous finirez avec une Version Produit de 1.0.* et une version de fichier de 1.0.0.0 . Pas ce que vous voulez!

cependant, si vous supprimer la seconde de ces lignes et juste avoir:

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

alors le compilateur définira la Version de fichier pour être égale à la Version de produit et vous obtiendrez votre résultat désiré d'un produit d'accroissement automatique et la version de fichier qui sont dans la synchronisation. E. g. 1.0.3266.92689

394
répondu Sam Meldrum 2008-12-10 19:35:54
la source

ouvrir le AssemblyInfo.cs fichier et le changement

// 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 au Projet - > Propriétés - > informations d'assemblage

cela cependant ne vous permettra d'augmenter automatiquement la version D'assemblage et vous donnera le

Assembly File Version: un joker ( " * ") n'est pas autorisé dans ce champ

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

il suffit donc d'ouvrir le assemblyinfo.cs et le faire manuellement.

146
répondu Hath 2013-06-21 03:16:44
la source

une autre option pour changer les numéros de version dans chaque build est d'utiliser la Version tâche de MSBuild.Communauté.Les tâches . Il suffit de télécharger leur installateur, de l'installer, puis d'adapter le code suivant et de le coller après <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> dans votre .csproj fichier:

<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: Adaptez la propriété StartDate à votre localité. il n'utilise actuellement pas l'invariant culture.

pour la troisième construction 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 ensuite être ajouté au projet (via ajouter l'article existant ), et les lignes AssemblyVersion et AssemblyFileVersion doivent être supprimées de AssemblyInfo.cs .

les différents algorithmes pour changer les composants de la version sont décrits dans $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm et Version "Propriétés De La 1519110920" .

50
répondu Christian 2012-10-18 13:02:59
la source

j'ai trouvé une solution similaire aux chrétiens, mais sans dépendre des tâches MSBuild de la communauté, 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 compiler à un assemblage et je veux auto-incrémenter les numéros de version. Cependant, je ne peux pas utiliser le VS 6.0.* AssemblyVersion tour qu'il s'est auto-incrémente le numéro de build de chaque jour et casse la compatibilité avec les Assemblées qui utilise un vieux construire le numéro. Au lieu de cela, je veux avoir une AssemblyVersion codée en dur mais une AssemblyFileVersion auto-incrémentée. J'ai réalisé ceci en spécifiant AssemblyVersion dans AssemblyInfo.cs et la génération d'un VersionInfo.cs dans MSBuild comme ça", 151920920"

  <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 une VersionInfo.fichier cs avec un attribut D'assemblage pour AssemblyFileVersion où la version suit le schéma de YY.MMM.DD.TTTT avec la date de construction. Vous devez inclure ce fichier dans votre projet et construire avec elle.

22
répondu Boog 2016-07-25 20:08:09
la source

Installer Version Incrément . Il vous donne plus de contrôle que l'option*.

16
répondu Ryan Gates 2012-09-26 00:46:43
la source

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

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

Également comme une note côté, le troisième nombre représente le nombre de jours depuis 2/1/2000 et le quatrième nombre est la moitié de la quantité totale de secondes dans la journée. Donc si vous compilez à minuit, ça devrait être zéro.

12
répondu Bob 2012-05-23 19:59:36
la source

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

autant que je sache, il n'a pas de travail dans VS 2005 (mais en VS 2003 et VS 2008). Pour VS 2005, vous pouvez utiliser les éléments suivants: Auto Incrément de version Visual Studio 2005 construire et le numéro de révision sur la compilation .

mais sachez que changer le numéro de version automatiquement n'est pas recommandé pour les assemblys avec nom fort. La raison en est que toutes les références à un tel assemblage doivent être mises à jour chaque fois que l'assemblage référencé est reconstruit en raison du fait que les références d'assemblage fortement nommées sont toujours une référence à une version d'assemblage spécifique. Microsoft change lui-même le numéro de version des assemblages .net Framework uniquement s'il y a des changements dans les interfaces. (NB: je cherche toujours le lien dans MSDN où je l'ai lu.)

8
répondu Dirk Vollmar 2008-12-10 19:03:28
la source

définit le numéro de version à" 1.0.*" et de remplir automatiquement dans les deux dernières certain nombre avec la date (en jours à partir d'un certain point) et le temps (la moitié de l'secondes à partir de minuit)

5
répondu James Curran 2008-12-10 18:54:35
la source

pour obtenir des informations incrémentantes (DateTime) dans la propriété AssemblyFileVersion qui a l'avantage de ne pas casser les dépendances.


construire sur la solution de Boog (n'a pas fonctionné pour moi, peut-être à cause de VS2008?), vous pouvez utiliser une combinaison d'un événement pré-construction générant un fichier, ajoutant ce fichier (y compris ses propriétés de version) et ensuite en utilisant un moyen de lire ces valeurs à nouveau. Qui est..

Pré-Construction-É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
"151920920 sont la résultante VersionInfo.fichier cs (Propriétés sous-dossier) 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 confortable.. aussi, je ne sais pas si elle crée beaucoup de force reconstruit (depuis un fichier change toujours).

vous pouvez le rendre plus intelligent par exemple si vous mettez à jour le VersionInfo.cs fichier toutes les quelques minutes / hours (en utilisant un fichier temporaire, puis en copiant/écrasant la VersionInfo réelle.cs si un changement assez grand est détecté). Je l'ai fait une fois assez réussi.

5
répondu Andreas Reiff 2012-07-10 22:37:31
la source

il y a une extension visual studio versions automatiques qui prend en charge Visual Studio 2012, 2013, 2015 et 2017.

Captures D'Écran enter image description here

enter image description here

5
répondu Rahul 2017-03-30 11:24:45
la source

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

http://screencast.com/t/Vj7rhqJO

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

4
répondu Alex 2017-02-08 17:09:22
la source

Cake prend en charge la correction des fichiers AssemblyInfo. Avec cake dans les mains vous avez des façons infinies de mettre en œuvre la version automatique incrémentation.

exemple Simple de version incrémentée comme le fait c# compiler:

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:

  • la Version est la version de l'assembly. La meilleure pratique consiste à verrouiller le numéro de la version principale et à laisser les autres avec des zéros (comme "1.0.0.0").
  • FileVersion-est la version de fichier d'assemblage.

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

4
répondu hal 2016-03-03 22:27:56
la source

aller au Projet | Propriétés puis Informations D'assemblage et ensuite version D'assemblage et mettre un * dans la dernière ou la deuxième à la dernière boîte (vous ne pouvez pas auto-incrémenter les composants majeurs ou mineurs).

3
répondu MusiGenesis 2008-12-10 19:01:17
la source

utilisez la tâche AssemblyInfo des tâches de la communauté MSBuild ( http://msbuildtasks.tigris.org / ) et l'intégrer dans votre .csproj/.fichier vbproj.

il a un certain nombre d'options, y compris une pour lier le numéro de version à la date et l'Heure de la journée.

recommandé.

2
répondu devstuff 2008-12-15 08:20:35
la source

à partir de maintenant, pour mon application,

string ver = Application.ProductVersion;

renvoie 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 splash de mon application. Lorsque je traite avec un utilisateur, je peux demander la date de création qui est plus facile à communiquer qu'un certain nombre long.

(je suis un homme-dept soutenir une petite entreprise. Cette approche peut ne pas fonctionner pour vous.)

2
répondu SeaDrive 2012-10-03 13:41:59
la source

Modification de la AssemblyInfo travaille dans VS2012. Il semble étrange qu'il n'y ait pas plus de support pour cela dans Visual Studio, on pourrait penser que c'était une partie fondamentale du processus de construction/publication.

2
répondu Maxcelcat 2014-01-24 10:01:49
la source

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

C'est un peu expérimental, mais je l'aime. Inspiré par Jeff Atwood @ Codinghorr ( link ).

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

  • pauvres mans zéro de remplissage (avec le stupide 1 s)
  • presque humainement lisible local DateTime intégré dans le numéro de version
  • laissant la version majeure seule pour les changements vraiment majeurs.

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

ensuite, lors de la sauvegarde de ce fichier, ou de la construction du projet, ce sera régénérer un fichier .cs situé comme sous-élément dans 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}" #>")]
2
répondu 2016-07-09 17:52:41
la source

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 appelez le chargement de formulaire.

Avec ce code, vous pouvez mettre à jour n'importe quelle partie de l'information de dossier dans AssemblyInfo.cs (mais vous devez utiliser la structure de répertoire "standard").

1
répondu Atiris 2013-05-14 02:26:24
la source

AssemblyInfoUtil . Gratuit. Open-source.

1
répondu Sergiy 2014-05-08 10:30:01
la source

j'utilise cette approche https://stackoverflow.com/a/827209/3975786 en plaçant le modèle T4 dans une" Solution Items "et en l'utilisant avec" Add as Link " dans chaque projet.

1
répondu mcandal 2017-05-23 15:02:57
la source

peut-être est-il trop tard pour répondre ici, mais l'espoir que cela résoudra le problème trépidant de quelqu'un.

une façon automatique de changer la version d'assemblage de tous vos projets en utilisant le script PowerShell. cet article résoudra beaucoup de vos problèmes.

1
répondu Khawaja Asim 2018-01-04 08:40:15
la source

chaque fois que je fais un build it augmente automatiquement le chiffre le moins significatif.

Je ne sais pas comment mettre à jour les autres, mais vous devriez au moins le voir déjà...

0
répondu Brian Knoblauch 2008-12-10 18:54:06
la source

j'ai créé une application pour incrémenter automatiquement la version du fichier.

  1. Télécharger Application
  2. ajouter la ligne suivante à la ligne de commande pré-construction

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

  3. construire le projet

à garder simple l'application ne lance des messages que s'il ya une erreur, pour confirmer qu'il a fonctionné très bien, vous aurez besoin de vérifier la version du fichier dans 'information D'assemblage'

Note: vous devrez recharger la solution dans Visual studio pour le bouton "Information D'assemblage" pour remplir les champs, cependant votre fichier de sortie aura la version mise à jour.

pour des suggestions et des demandes s'il vous plaît envoyez-moi un courriel à [email protected]

0
répondu Telson Alva 2017-06-23 14:33:30
la source