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

358

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 )

en dépit
la source
1
le caractère générique ne semble fonctionner que pour AssemblyVersion, mais pas pour AssemblyFileVersion dans VS 2005
dotnetcoder
Existe-t-il des solutions à cela qui fonctionnent pour les projets C ++ dans VS2005? Toutes les réponses semblent renvoyer à .Net. Question connexe . Merci
Deanna
Dans les projets .Net Core , l'incrémentation automatique AssemblyVersion ne fonctionne pas par défaut. Vous devez ajouter <Deterministic> False </Deterministic> à csproj. Voir Auto Versioning dans Visual Studio 2017 (.NET Core)
Michael Freidgeim

Réponses:

434

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

Sam Meldrum
la source
2
Cela fonctionne aussi bien que n'importe quoi d'autre, et fonctionne dans VS2005. J'espérais un certain nombre rationnel comme 1.0.1.56 à la place, j'obtiens 1.0.3266.30135 mais au moins il augmente (bien que par un nombre aléatoire: D)
malgré
14
oh je viens de le lire: 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)
malgré
20
Joli appel sur la nécessité de supprimer l'attribut AssemblyFileVersion pour que cela fonctionne!
David Faivre
76
Je me rends compte que c'est une vieille question, mais je voulais ajouter ce commentaire pour ceux qui trouvent leur chemin vers cette réponse. Si vous incrémentez AssemblyVersion, tout projet utilisant votre DLL devra être recompilé. Cependant, si vous conservez la AssemblyVersion la même et incrémentez la AssemblyFileVersion par elle-même, vous pouvez échanger la nouvelle DLL sans avoir à recompiler ce qui l'utilise. Alors demandez-vous ceci, est-ce juste une nouvelle construction, ou suis-je en train de publier une nouvelle version?
onefootswill
27
@ DD59 le 'Build' est le nombre de jours depuis le 1er janvier 2000; la «Révision» est une seconde à partir de minuit divisée par 2 (pas des demi-secondes, mais des intervalles de deux secondes). Voir ici: stackoverflow.com/a/3387167/11545
Cristian Diaconescu
154

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.

Hath
la source
Oui, je viens de rencontrer le "" Version du fichier d'assemblage: un caractère générique ("*") n'est pas autorisé dans ce champ "c'est ce qui a valu à votre méthode la coche verte: D
malgré
3
cela fonctionne: [assembly: AssemblyVersion ("1.0. *")] // [assembly: AssemblyFileVersion ("1.0.0.0")]
malgré
4
Il n'est pas souhaitable de modifier le numéro AssemblyVersion pendant un cycle de version. Au lieu de cela, AssemblyFileVersion doit être modifié. Voir mon article de blog sur ce sujet: philippetruche.wordpress.com/2008/08/12/… Voir également l'excellent article de Suzanne Cook sur le moment de changer les chiffres: blogs.msdn.com/b/suzcook/archive/2003/05/ 29 / 57148.aspx
Philippe
46
Je serais prudent en utilisant le * il cessera de fonctionner le 4 juin 2179 lorsque le jour deviendra 65536
Lloyd Powell
3
@Shimmy: Ajoutez <Deterministic> False </Deterministic> à .csproj Auto Versioning dans Visual Studio 2017 (.NET Core)
Michael Freidgeim
53

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 .

Christian
la source
2
C'est le meilleur moyen à ce jour que j'ai vu pour contourner le fait affreux que les structures FileVersion utilisent des entiers 16 bits.
Mike Post
1
J'ai rencontré des problèmes lors de l'installation dans VS2012 à l'aide de la console de package, je vous recommande donc d'utiliser les installateurs msi nocturnes téléchargés sur github.com/loresoft/msbuildtasks/downloads . Fonctionne copier / coller à partir de ce qui précède. Merci!
DaveO
Après avoir été refusé et modifié sur ce post: "Vous pouvez également vérifier ce loresoft.com/projects/msbuildtasks/… il peut améliorer les fonctionnalités de base décrites précédemment."
radu florescu
1
Ce n'est pas une solution viable pour ceux qui construisent avec TFS. Ultimatey, cela ajoutera une modification en attente aux fichiers VersionInfo.cs et version.txt. Pour moi, il n'est pas souhaitable d'avoir une modification en attente pour chaque build.
JDennis
@JDennis voir ici pour des conseils de versioning TFS ...
Christian
25

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.

Boog
la source
MSBuild prend-il en charge les variables? Il serait préférable d'en mettre [System.DateTime]::Nowun, sinon, il y a une condition de concurrence qui peut entraîner l'utilisation d'un ancien numéro de build si vous construisez vers minuit.
Edward Brey
Avez-vous défini ces quatre propriétés au lieu de les combiner en une seule DateTime.ToStringà des fins de démonstration, ou y a-t-il une raison particulière?
mafu
Si votre événement BeforeBuild ne se déclenche pas dans VS2017, consultez stackoverflow.com/questions/43921992/…
Rhys Jones
Cette solution est la meilleure solution parmi toutes les réponses ici. Cependant, le problème est que l'horodatage (ou le contenu du fichier versioninfo.cs) ne se met pas à jour si vous générez le projet pour la deuxième fois, ce qui devrait produire une minute différente. Si je ferme et recharge le projet, l'horodatage est mis à jour. Est-ce un bug de MSBuild? @Boog
Cary
12

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.

Bob
la source
12

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

Captures d'écran entrez la description de l'image ici

entrez la description de l'image ici

Rahul
la source
Je l'ai donc désinstallé et je peux en dire plus ... il modifie le fichier csproj d'origine. Je pense que c'est une extension très problématique.
Maxim
2
@Maxim Essayez la dernière version, cela devrait fonctionner sur VS 2017
Rady
Excellent util. Fonctionne bien pour moi dans vs2017. Les documents pourraient être légèrement plus clairs, mais installez-le (via le site) puis installez MSBuild via Nuget, appliquez-le à un petit projet et jouez et construisez. Agréable. @ La réponse de Boog n'a pas fonctionné pour moi, bien qu'il ait dit exactement ce que j'essayais de réaliser.
err1
8

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

Dirk Vollmar
la source
Je pense que pour n'importe quelle version de VS, vous ne pouvez mettre le * que dans les cases Build ou Revision. Je viens de l'essayer en utilisant VS 2005, et cela fonctionne très bien. Je ne sais pas de quoi l'auteur de cet article de projet de code parle.
MusiGenesis
Peut-être qu'il est revenu avec un service pack, mais je me souviens qu'il ne fonctionnait pas quand j'utilisais VS 2005.
Dirk Vollmar
Cela ne fonctionne pas avec 2005, je vais chercher un service pack et faire un rapport.
inspite
Peut-être que MusiGenesis a installé un module complémentaire qui permet la gestion automatique des versions.
Dirk Vollmar
@divo: non, je suis phobique. Je viens d'avoir Visual Studio 2005 Professional SP1. Je n'ai jamais vu de problème avec le *, mais j'incrémente généralement manuellement. Cela ressemble à un bug bizarre.
MusiGenesis
6

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.

Andreas Reiff
la source
Cela fonctionne parfaitement. Cependant, cette expression régulière% date: ~ -4,4%.% Date: ~ -7,2 %% date: ~ -10,2%.% Temps: ~ 0,2 %% temps: ~ 3,2% .% time: ~ -5,2% "est tout simplement trop compliqué.
Cary
5

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)

James Curran
la source
Hé, si j'avais bien lu au début, je me serais sauvé beaucoup d'agro. thx
inspite
4

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 .

hal
la source
3

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

MusiGenesis
la source
2

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é.

devstuff
la source
2

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

SeaDrive
la source
Votre numéro va s'épuiser rapidement. J'utiliserais yyddd, qui est une année à 2 chiffres et un jour à 3 chiffres à partir du début de l'année, ce qui correspond à 365 au maximum. étant donné que votre programme est toujours en service à cette date!
AaA
2

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.

Maxcelcat
la source
2

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

la source
Vous ne compilez pas votre programme toutes les minutes ou ne déployez pas plus d'une fois par jour, donc techniquement, la partie temps occupe inutilement des informations précieuses, j'utiliserais les 1er et 2e pour les mineurs majeurs et j'utiliserais juste le 3e nombre pour la date yyddd (année à deux chiffres + jjj à partir du début de la même année) et laissez le 4e pour le numéro de version incrémentiel.
AaA
2

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]

Telson Alva
la source
2

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
Madacol
la source
1

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

Atiris
la source
1

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.

Khawaja Asim
la source
Le seul problème avec PS est qu'il est lent à réagir et nécessite une configuration pour lui permettre de fonctionner. J'irais avec un petit exécutable, un fichier tt4 ou même du code en ligne que je pense que n'importe quel programmeur peut écrire dans un sens.
AaA
0

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à ...

Brian Knoblauch
la source
1
Le VS est chargé d'incrémenter le dernier numéro qui est généralement le numéro de build. Tout le reste (c'est-à-dire les chiffres avant cela) dépend de vous car ils représentent la version de votre application.
Огњен Шобајић
1
Огњен Шобајић: Pas tout à fait raison. Le schéma de numérotation de Microsoft est major.minor.build.revision, par exemple 1.0.4.7. Si vous définissez la version de l'assembly sur quelque chose comme "1.0. *", VS définira les numéros de version et de révision pour vous. Dans ce cas, la construction augmentera quotidiennement et la révision sera le nombre de secondes depuis minuit, divisé par 2.
Simon Tewsi
0

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.

John Denniston
la source