Je me demandais simplement comment je pouvais incrémenter automatiquement la génération (et la version?) De mes fichiers à l'aide de Visual Studio (2005).

Si je recherche les propriétés de dis C:\Windows\notepad.exe, l'onglet Version donne "Version du fichier: 5.1.2600.2180". Je voudrais obtenir ces chiffres sympas dans la version de mes DLL aussi, pas dans la version 1.0.0.0, qui avouons que c'est un peu terne.

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

Je travaille principalement sur 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 croire que tant d'efforts pour faire quelque chose soit une pratique standard.

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 œuvres suivantes.

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 cela en:

[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 pour être égale à la version du produit et vous obtiendrez le résultat souhaité d'une incrémentation automatique du produit et de la version 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 dans IDE en accédant à project -> properties -> assembly information

Cependant, cela ne vous permettra d'incrémenter automatiquement la version de l'assemblage et vous donnera la

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

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

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

Une autre option pour modifier les numéros de version dans chaque build 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 ensuite <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />dans votre .csprojfichier:

<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. Il n'utilise actuellement pas la culture invariante.

Pour la troisième version du 14 janvier 2010, cela crée un VersionInfo.csavec 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 AssemblyVersionet AssemblyFileVersiondoivent être supprimées de AssemblyInfo.cs.

Les différents algorithmes de modification des composants de version sont décrits dans $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chmet Propriétés de version .

J'ai trouvé une solution similaire aux chrétiens mais sans dépendre des tâches de la communauté 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 je le compile dans un assembly et je souhaite incrémenter automatiquement les numéros de version. Cependant, je ne peux pas utiliser l'astuce VS 6.0. * AssemblyVersion car il incrémente automatiquement les numéros de build chaque jour et rompt la compatibilité avec les assemblys qui utilisent un numéro de build plus ancien. Au lieu de cela, je veux avoir une AssemblyVersion codée en dur mais une AssemblyFileVersion à incrémentation automatique. J'ai accompli cela en spécifiant AssemblyVersion dans AssemblyInfo.cs et en générant un VersionInfo.cs dans MSBuild comme ceci,

  <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 créer avec lui.

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 comme note secondaire, le troisième nombre 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.

Il existe une extension Visual Studio Automatic Versions qui prend en charge Visual Studio (2012, 2013, 2015) 2017 et 2019.

Captures d'écran

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 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: 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 à 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 à nom fort sont toujours une référence à une version d'assembly spécifique. Microsoft ne modifie lui-même le numéro de version des assemblys .NET Framework qu'en cas de modifications des interfaces. (NB: je recherche toujours le lien dans MSDN où je l'ai lu.)

Pour obtenir des informations d'incrémentation (DateTime) dans la propriété AssemblyFileVersion qui a l'avantage de ne casser aucune dépendance.

En s'appuyant 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 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 lire ces valeurs à nouveau. C'est..

Événement pré-build:

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 Propriétés) 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 ça crée pas mal 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 / écrasant le vrai VersionInfo.cs si un changement suffisamment important est détecté). Je l'ai fait une fois avec succès.

Réglez 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)

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

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

Cake prend en charge les correctifs des fichiers AssemblyInfo. Avec cake in hands, vous disposez de moyens infinis pour implémenter l'incrémentation de version automatique.

Un exemple simple de version incrémentée comme le 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 d'assemblage. La meilleure pratique consiste à verrouiller le numéro de version principale et à laisser les zéros (comme "1.0.0.0").
• FileVersion - est la version du fichier d'assemblage.

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

Aller au projet | Propriétés, puis Informations sur l'assemblage, puis Version de l'assemblage et mettez un * dans la dernière ou l'avant-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 a un certain nombre d'options, dont une pour lier le numéro de version à la date et à l'heure.

Conseillé.

En ce moment, pour ma candidature,

string ver = Application.ProductVersion;

Retour 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 qu'un certain nombre long.

(Je suis un chef d'équipe 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 prise en charge pour cela dans Visual Studio, vous penseriez que c'était une partie de base du processus de génération / publication.

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 résultant devient 1.2016.10709.11641(ce qui signifie 2016-07-09 16:41), ce qui permet

• pauvre homme zéro padding (avec les 1s stupides en tête )
• DateTime locale presque lisible par l'homme intégrée dans le numéro de version
• laissant la version Major seule pour des changements de rupture vraiment majeurs.

Ajouter un nouvel élément à votre projet, sélectionnez Général -> Texte de modèle, nommez quelque chose comme CustomVersionNumberet ( le cas échéant) le commentaire AssemblyVersionet AssemblyFileVersiondans Properties/AssemblyInfo.cs.

Ensuite, lors de l'enregistrement de ce fichier ou de la création du projet, cela régénérera un .csfichier situé en tant que sous-élément sous le .ttfichier 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}" #>")]

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

1. Téléchargez 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 rester simple, l'application ne lance des messages qu'en cas d'erreur, pour confirmer que cela a bien fonctionné, vous devrez 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, mais votre fichier de sortie aura la version mise à jour.

Pour des suggestions et des demandes, veuillez m'envoyer un e-mail à [email protected]

Dans Visual Studio 2019

Ce n'était pas suffisant pour moi d'ajouter

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

Lors de la construction, il me lance cette erreur

La chaîne de version spécifiée n'est pas conforme au format requis

Solution

Le format a été finalement acceptée après avoir fixé Deterministicà Falseenproject.csproj

<Deterministic>false</Deterministic>

Éditer:

Pour certains réglage de la raison Deterministicpour Falsefoiré mon fichier de configuration charger et enregistrer sur des endroits différents.

Solution de contournement:

J'ai configuré un événement post-build pour incrémenter le numéro de révision:

Script de lot d'événements post-build

Cela appelle un script PowerShell nommé autoincrement_version.ps1passant comme argument le chemin deAssemblyInfo.cs

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

Script Poweshell

Il incrémente automatiquement le numéro de révision à l'aide de 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

Peut-être, 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);
                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 de fichier dans AssemblyInfo.cs (mais vous devez utiliser une structure de répertoire "standard").

AssemblyInfoUtil . Gratuit. Open source.

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

Il est peut-être trop tard pour répondre ici, mais j'espère que cela résoudra le problème mouvementé de quelqu'un.

Un moyen automatique de modifier la version d'assemblage de tous vos projets à l'aide du script PowerShell. Cet article résoudra bon nombre de vos problèmes.

Chaque fois que je fais une construction, il 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à ...

Pour toute personne utilisant Tortoise Subversion, vous pouvez lier l'un de vos numéros de version au numéro de révision subversion de votre code source. Je trouve cela très utile (les auditeurs aiment vraiment ça aussi!). Pour ce faire, appelez l'utilitaire WCREV dans votre pré-génération et générez vos AssemblyInfo.cs à partir d'un modèle.

Si votre modèle s'appelle AssemblyInfo.wcrev et se trouve dans le répertoire AssemblyInfo.cs normal, et tortoise se trouve dans le répertoire d'installation par défaut, alors votre commande Pre-Build ressemble à ceci (NB All on one line):

"C:\Program Files\TortoiseSVN\bin\SubWCRev.exe" "$(ProjectDir)." "$(ProjectDir)Properties\AssemblyInfo.wcrev"  "$(ProjectDir)Properties\AssemblyInfo.cs"

Le fichier modèle inclurait la chaîne de substitution de jeton wcrev: $ WCREV $
eg

[assembly: AssemblyFileVersion("1.0.0.$WCREV$")]

Remarque:
Comme votre AssemblyInfo.cs est maintenant généré, vous ne voulez pas que sa version soit contrôlée.