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.

Installer Version Incrément . Il vous donne 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/é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.

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

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)

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.

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

Captures D'Écran

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

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

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 .

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

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

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

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.

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

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

AssemblyInfoUtil . Gratuit. Open-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.

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.

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

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 à telson_alva@yahoo.com