Puis-je incrémenter automatiquement la version de compilation de fichiers lors de l'utilisation de Visual Studio?

StackOverflow https://stackoverflow.com/questions/356543

Question

Je me demandais 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 dire C:\Windows\notepad.exe, l'onglet Version donne « Version du fichier: 5.1.2600.2180 ». Je voudrais obtenir ces chiffres frais dans la version de mon 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 hors de fonctionnalités prêtes, ou peut-être que je ne fais que regarder au mauvais endroit (comme d'habitude).

Je travaille avec principalement des projets web ....

Je regardais 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 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 )

Était-ce utile?

La solution

Dans Visual Studio 2008, les travaux suivants.

Recherchez 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 finirez avec une version de produit 1.0. * et un fichier de version 1.0.0.0 . Pas ce que vous voulez!

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

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

Ensuite, le compilateur définir la version du fichier égale à la version du produit et vous obtiendrez le résultat souhaité d'un produit incrément automatiquement et la version fichier qui sont synchronisés. Par exemple. 1.0.3266.92689

Autres conseils

ouvrir le fichier AssemblyInfo.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 de la version Assemblée et vous donnera la

  

Assemblée Version du fichier: Un caractère générique ( "*") n'est pas autorisé dans ce domaine

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

Alors il suffit d'ouvrir les AssemblyInfo.cs et le faire manuellement.

Une autre option pour modifier les numéros de version dans chaque version est d'utiliser la tâche de Version href="https://github.com/loresoft/msbuildtasks" rel="noreferrer"> MSBuild .Community.Tasks . Il suffit de télécharger leur programme d'installation, l'installer, puis adapter le code suivant et collez-le dans votre après <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> 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: Adapter la propriété startDate à vos paramètres régionaux. Actuellement, il ne pas utiliser la culture invariante.

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

[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 la ligne AssemblyVersion et doivent AssemblyFileVersion être retiré de AssemblyInfo.cs.

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

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

Je suis génération de code et la compilation à une assemblée et que vous souhaitez les numéros de version auto-incrément. Cependant, je ne peux pas utiliser le VS 6.0. * Truc AssemblyVersion comme il incrémente automatiquement les numéros de build chaque jour de compatibilité et les pauses avec les assemblées qui utilisent un numéro de version plus ancienne. , Je veux plutôt que d'avoir un AssemblyVersion codé en dur, mais un 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 ça, 

  <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 Assemblée pour AssemblyFileVersion où la version suit le schéma de YY.MM.DD.TTTT à la date de construction. Vous devez inclure ce fichier dans votre projet et de construire avec elle.

Installer le href="http://autobuildversion.codeplex.com/" Construire Increment Version add-in. Il vous donne un contrôle beaucoup plus que l'option *.

Pour obtenir les numéros de version essayer 

 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.*")]

En outre comme une note de côté, le troisième numéro est le nombre de jours écoulés depuis 2/1/2000 et le quatrième numéro est la moitié de la quantité de secondes au total dans la journée. Donc, si vous compilez à minuit, il devrait être nul.

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

Captures d'écran entrer la description d'image ici

ici

Définition d'un * dans le numéro de version dans AssemblyInfo ou dans les propriétés du projet tel que décrit dans les autres postes ne fonctionne pas avec toutes les versions de Visual Studio / .NET.

Autant que je sache, il ne fonctionne 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 numéro de compilation et de révision sur la compilation temps .

Mais il faut savoir que changer le numéro de version est pas recommandée automatiquement pour les assemblées nom fort. La raison en est que toutes les références à une telle assemblée doit être mis à jour chaque fois que l'ensemble référencé est reconstruit en raison du fait que les références d'assemblage nom fort sont toujours une référence à une version spécifique d'assemblage. Microsoft se changer le numéro de version des ensembles .NET Framework uniquement s'il y a des changements dans les interfaces. (NB:. Je cherche toujours le lien dans MSDN où je lis que)

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

Miser 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), puis en utilisant un moyen pour lire 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 mettez à jour uniquement les VersionInfo.cs fichier toutes les quelques minutes / heures (en utilisant un fichier temporaire, puis copier / écraser les vrais VersionInfo.cs si on détecte un changement assez grand). Je l'ai fait une fois avec assez de succès.

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)

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

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

gâteau prend en charge les fichiers AssemblyInfo rapiéçage. Avec un gâteau en mains, vous avez une infinité de manières de mettre en œuvre la version automatique incrémenter.

Exemple simple de la version incrémenter comme 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 = 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 majeur et ne laisser subsister avec des zéros (comme « 1.0.0.0 »).
  • FileVersion - est une version de fichier d'assemblage
    • .

Notez que vous pouvez patcher versions non seulement, mais aussi tous les renseignements nécessaires .

Aller au projet | Propriétés et puis l'information de l'Assemblée puis Version Assemblée et mettre un * dans le dernier ou le deuxième à la dernière case (vous ne pouvez pas auto-augmentation de la majeure ou des composants mineurs).

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

Il a un certain nombre d'options, dont un pour attacher le numéro de version à la date et l'heure de la journée.

. Recommandée

En ce moment, pour ma demande, 

string ver = Application.ProductVersion;

retourne 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. Lorsque vous traitez avec un utilisateur, je peux demander la date de création qui est plus facile de communiquer que certains nombre longtemps.

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

Modification du AssemblyInfo fonctionne dans VS2012. Il semble étrange qu'il n'y a pas plus de soutien pour cela dans Visual Studio, vous penseriez que cela faisait partie de base du processus de construction / de sortie.

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 ( ).

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

  • pauvres mans remplissage de zéros (à l'bête menant 1 s)
  • lisible presque humain locale DateTime intégré dans le numéro de version
  • laissant la version majeure seule pour les changements de rupture vraiment importantes.

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

Ensuite, lors de l'enregistrement de ce fichier, ou la construction du projet, cela va régénérer un fichier situé en .cs sous-élément dans 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}" #>")]

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 une partie de l'info de fichier dans AssemblyInfo.cs (mais vous devez utiliser la structure de répertoire « standard »).

AssemblyInfoUtil . Libre. Open source.

J'utilise cette approche https://stackoverflow.com/a/827209/3975786 en plaçant le T4 modèle dans une « solution des éléments » et l'utiliser avec « Ajouter comme lien » au sein de chaque projet.

Peut-être qu'il est trop tard pour répondre ici, mais l'espoir qui résoudre le problème mouvementé de quelqu'un.

Une façon automatique pour changer la version de l'assemblage de tous vos projets à l'aide de scripts PowerShell. Cet article sera résoudre beaucoup de vos problèmes.

Chaque fois que je fais construire ce incrémente automatiquement le chiffre le moins significatif.

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

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

  1. Télécharger application

  2. ajoutez la ligne suivante à commande événement pré-construction ligne

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

  3. Générez le projet

Pour simplifier l'application jette uniquement les messages en cas d'erreur, pour le confirmer a bien fonctionné, vous devrez vérifier la version du fichier « Informations Assemblée »

Note:. Vous devrez recharger la solution dans Visual Studio pour le bouton « information de l'Assemblée » pour remplir les champs, mais votre fichier de sortie aura la version mise à jour

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

Dans Visual Studio 2019

Il ne suffit pas pour moi d'ajouter 

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

Lors de la construction, il me jette cette erreur

  

La chaîne de version spécifiée ne se conforme pas au format requis

Solution

Le format a finalement été acceptée après que je mis à Deterministic dans False project.csproj 

<Deterministic>false</Deterministic>

Edit:

Pour certains réglage de la raison pour autoincrement_version.ps1 foiré mon AssemblyInfo.cs fichier de configuration charger et enregistrer sur différents endroits.

Solution:

configuration I un événement post-build pour incrémenter le numéro de révision:

Post-script de construction de lot d'événements

appelle un script Powershell nommé comme argument qui passe <=> le chemin de <=> 

if $(ConfigurationName) == Release (
PowerShell -ExecutionPolicy RemoteSigned $(ProjectDir)autoincrement_version.ps1 '$(ProjectDir)My Project\AssemblyInfo.cs'
)

Script Poweshell

Il autoincrements le numéro de révision utilisant l'expression rationnelle 

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
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top